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

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

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

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

_ZN8usbguard18LocaltimeConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   36|  3.37k|    : RuleConditionBase("localtime", time_range, negated)
   37|  3.37k|  {
   38|  3.37k|    std::string time_begin;
   39|  3.37k|    std::string time_end;
   40|  3.37k|    const size_t dash_pos = time_range.find('-');
   41|       |
   42|  3.37k|    if (dash_pos == std::string::npos) {
  ------------------
  |  Branch (42:9): [True: 834, False: 2.54k]
  ------------------
   43|    834|      time_begin = time_range;
   44|    834|    }
   45|  2.54k|    else {
   46|  2.54k|      time_begin = time_range.substr(0, dash_pos);
   47|  2.54k|      time_end = time_range.substr(dash_pos + 1);
   48|  2.54k|    }
   49|       |
   50|  3.37k|    _daytime_begin = stringToDaytime(time_begin);
   51|       |
   52|  3.37k|    if (!time_end.empty()) {
  ------------------
  |  Branch (52:9): [True: 1.34k, False: 2.03k]
  ------------------
   53|  1.34k|      _daytime_end = stringToDaytime(time_end);
   54|  1.34k|    }
   55|  2.03k|    else {
   56|  2.03k|      _daytime_end = _daytime_begin;
   57|  2.03k|    }
   58|       |
   59|  3.37k|    if (_daytime_begin > _daytime_end) {
  ------------------
  |  Branch (59:9): [True: 34, False: 3.34k]
  ------------------
   60|     34|      throw Exception("LocaltimeCondition", "Invalid time range (begin > end)", time_range);
   61|     34|    }
   62|  3.37k|  }
_ZN8usbguard18LocaltimeConditionC2ERKS0_:
   65|  5.16k|    : RuleConditionBase(rhs)
   66|  5.16k|  {
   67|  5.16k|    _daytime_begin = rhs._daytime_begin;
   68|  5.16k|    _daytime_end = rhs._daytime_end;
   69|  5.16k|  }
_ZNK8usbguard18LocaltimeCondition5cloneEv:
   82|  5.16k|  {
   83|  5.16k|    return new LocaltimeCondition(*this);
   84|  5.16k|  }
_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: 4.43k, False: 283]
  ------------------
  117|  4.43k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (117:11): [True: 234, False: 4.20k]
  ------------------
  118|    234|        throw Exception("LocaltimeCondition", "Invalid time or range format", string);
  119|    234|      }
  120|  4.43k|    }
  121|       |
  122|  4.48k|    USBGUARD_LOG(Trace) << "tm=" << tmToString(&tm);
  ------------------
  |  |  299|  4.48k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level))                                                            \
  |  |  ------------------
  |  |  |  |  294|  4.48k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (299:7): [True: 0, False: 4.48k]
  |  |  ------------------
  |  |  300|  4.48k|  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.48k|    return tm.tm_sec + 60 * tm.tm_min + 60 * 60 * tm.tm_hour;
  124|  4.71k|  }

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

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

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

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

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

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

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

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

_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.20k|  {
  301|  9.20k|    return std::unique_lock<std::mutex>(_mutex);
  302|  9.20k|  }
_ZNK8usbguard6Logger9isEnabledENS_9LogStream5LevelE:
  312|  9.20k|  {
  313|  9.20k|    auto L = lock();
  314|  9.20k|    return (_enabled && _level >= level);
  ------------------
  |  Branch (314:13): [True: 9.20k, False: 0]
  |  Branch (314:25): [True: 0, False: 9.20k]
  ------------------
  315|  9.20k|  }
_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|   120k|    : d_pointer(usbguard::make_unique<RulePrivate>())
   42|   120k|  {
   43|   120k|  }
_ZN8usbguard4RuleD2Ev:
   45|   120k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   53|  77.5k|  {
   54|  77.5k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   55|  77.5k|    return *this;
   56|  77.5k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   69|  42.4k|  {
   70|  42.4k|    d_pointer->setTarget(target);
   71|  42.4k|  }
_ZNK8usbguard4Rule9getTargetEv:
   74|  13.2k|  {
   75|  13.2k|    return d_pointer->getTarget();
   76|  13.2k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   79|  3.56k|  {
   80|  3.56k|    d_pointer->setDeviceID(value);
   81|  3.56k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   94|   797k|  {
   95|   797k|    return d_pointer->attributeDeviceID();
   96|   797k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  114|  9.30k|  {
  115|  9.30k|    return d_pointer->attributeSerial();
  116|  9.30k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  134|  7.51k|  {
  135|  7.51k|    return d_pointer->attributeLabel();
  136|  7.51k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  154|  9.23k|  {
  155|  9.23k|    return d_pointer->attributeWithConnectType();
  156|  9.23k|  }
_ZN8usbguard4Rule13attributeNameEv:
  174|   594k|  {
  175|   594k|    return d_pointer->attributeName();
  176|   594k|  }
_ZN8usbguard4Rule13attributeHashEv:
  194|  13.4k|  {
  195|  13.4k|    return d_pointer->attributeHash();
  196|  13.4k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  214|  9.61k|  {
  215|  9.61k|    return d_pointer->attributeParentHash();
  216|  9.61k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  234|  11.5k|  {
  235|  11.5k|    return d_pointer->attributeViaPort();
  236|  11.5k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  244|   168k|  {
  245|   168k|    return d_pointer->attributeWithInterface();
  246|   168k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  254|   815k|  {
  255|   815k|    return d_pointer->attributeConditions();
  256|   815k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  328|  42.3k|  {
  329|  47.9k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (329:28): [True: 47.9k, False: 0]
  ------------------
  330|  47.9k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (330:11): [True: 42.3k, False: 5.54k]
  ------------------
  331|  42.3k|        return ttable_entry.second;
  332|  42.3k|      }
  333|  47.9k|    }
  334|       |
  335|      0|    throw std::runtime_error("Invalid rule target string");
  336|  42.3k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  381|  16.1k|  {
  382|  58.2k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (382:28): [True: 58.2k, False: 0]
  ------------------
  383|  58.2k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (383:11): [True: 16.1k, False: 42.1k]
  ------------------
  384|  16.1k|        return ttable_entry.second;
  385|  16.1k|      }
  386|  58.2k|    }
  387|       |
  388|      0|    throw std::runtime_error("Invalid set operator string");
  389|  16.1k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  296|  3.69k|      {
  297|  3.69k|        return count() == 0;
  298|  3.69k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  285|  10.8k|      {
  286|  10.8k|        return _values.size();
  287|  10.8k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  245|  1.65k|      {
  246|  1.65k|        _set_operator = op;
  247|  1.65k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  275|   796k|      {
  276|   796k|        _values.push_back(value);
  277|   796k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  296|  22.2k|      {
  297|  22.2k|        return count() == 0;
  298|  22.2k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  285|  22.2k|      {
  286|  22.2k|        return _values.size();
  287|  22.2k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  245|  10.6k|      {
  246|  10.6k|        _set_operator = op;
  247|  10.6k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  275|   622k|      {
  276|   622k|        _values.push_back(value);
  277|   622k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  296|  3.52k|      {
  297|  3.52k|        return count() == 0;
  298|  3.52k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  285|  3.52k|      {
  286|  3.52k|        return _values.size();
  287|  3.52k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  245|  2.03k|      {
  246|  2.03k|        _set_operator = op;
  247|  2.03k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  275|   163k|      {
  276|   163k|        _values.push_back(value);
  277|   163k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  296|  6.79k|      {
  297|  6.79k|        return count() == 0;
  298|  6.79k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  285|  6.79k|      {
  286|  6.79k|        return _values.size();
  287|  6.79k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  245|  1.74k|      {
  246|  1.74k|        _set_operator = op;
  247|  1.74k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  265|   805k|      {
  266|   805k|        _values.emplace_back(std::move(value));
  267|   805k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  237|  77.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  237|   543k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  237|  77.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  237|  77.5k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  220|   198k|      {
  221|   198k|        _name = name;
  222|   198k|        _set_operator = SetOperator::Equals;
  223|   198k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  220|  1.38M|      {
  221|  1.38M|        _name = name;
  222|  1.38M|        _set_operator = SetOperator::Equals;
  223|  1.38M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  220|   198k|      {
  221|   198k|        _name = name;
  222|   198k|        _set_operator = SetOperator::Equals;
  223|   198k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  220|   198k|      {
  221|   198k|        _name = name;
  222|   198k|        _set_operator = SetOperator::Equals;
  223|   198k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  380|  3.56k|      {
  381|  3.56k|        if (count() > 1) {
  ------------------
  |  Branch (381:13): [True: 0, False: 3.56k]
  ------------------
  382|      0|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  383|      0|        }
  384|       |
  385|  3.56k|        if (count() == 0) {
  ------------------
  |  Branch (385:13): [True: 3.56k, False: 0]
  ------------------
  386|  3.56k|          append(value);
  387|  3.56k|        }
  388|      0|        else {
  389|      0|          _values[0] = value;
  390|      0|        }
  391|  3.56k|      }

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

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

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

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

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

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

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    267|{
   36|    267|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    267|   constexpr auto begin = sv.find( '=' );
   38|    267|   static_assert( begin != std::string_view::npos );
   39|    267|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    267|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    365|{
   36|    365|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    365|   constexpr auto begin = sv.find( '=' );
   38|    365|   static_assert( begin != std::string_view::npos );
   39|    365|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    365|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.31k|{
   36|  1.31k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.31k|   constexpr auto begin = sv.find( '=' );
   38|  1.31k|   static_assert( begin != std::string_view::npos );
   39|  1.31k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.31k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     66|{
   36|     66|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     66|   constexpr auto begin = sv.find( '=' );
   38|     66|   static_assert( begin != std::string_view::npos );
   39|     66|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     66|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    289|{
   36|    289|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    289|   constexpr auto begin = sv.find( '=' );
   38|    289|   static_assert( begin != std::string_view::npos );
   39|    289|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    289|}
_ZN3tao5pegtl8demangleINS0_3eofEEENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEv:
   35|  4.58k|{
   36|  4.58k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.58k|   constexpr auto begin = sv.find( '=' );
   38|  4.58k|   static_assert( begin != std::string_view::npos );
   39|  4.58k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.58k|}

_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|  45.2k|      {
   45|  45.2k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  45.2k|      }
_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|  42.0k|      {
   45|  42.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  42.0k|      }
_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|  37.8k|      {
   45|  37.8k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  37.8k|      }
_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|  34.0k|      {
   45|  34.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  34.0k|      }
_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|  31.2k|      {
   45|  31.2k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  31.2k|      }
_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|  28.2k|      {
   45|  28.2k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  28.2k|      }
_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|  24.6k|      {
   45|  24.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  24.6k|      }
_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|  21.5k|      {
   45|  21.5k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  21.5k|      }
_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|  18.6k|      {
   45|  18.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  18.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|  12.6k|      {
   45|  12.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  12.6k|      }

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

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

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

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.09M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.09M|      else {
   20|  4.09M|         in.bump_in_this_line( count );
   21|  4.09M|      }
   22|  4.09M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  13.2k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  13.2k|      else {
   20|  13.2k|         in.bump_in_this_line( count );
   21|  13.2k|      }
   22|  13.2k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  38.6k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  38.6k|      else {
   20|  38.6k|         in.bump_in_this_line( count );
   21|  38.6k|      }
   22|  38.6k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.80k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.80k|      else {
   20|  2.80k|         in.bump_in_this_line( count );
   21|  2.80k|      }
   22|  2.80k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|      9|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|      9|      else {
   20|      9|         in.bump_in_this_line( count );
   21|      9|      }
   22|      9|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    851|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    851|      else {
   20|    851|         in.bump_in_this_line( count );
   21|    851|      }
   22|    851|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     42|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     42|      else {
   20|     42|         in.bump_in_this_line( count );
   21|     42|      }
   22|     42|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.41M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.41M|      else {
   20|  1.41M|         in.bump_in_this_line( count );
   21|  1.41M|      }
   22|  1.41M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.73M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.73M|      else {
   20|  1.73M|         in.bump_in_this_line( count );
   21|  1.73M|      }
   22|  1.73M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.12M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.12M|      else {
   20|  1.12M|         in.bump_in_this_line( count );
   21|  1.12M|      }
   22|  1.12M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.69k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.69k|      else {
   20|  3.69k|         in.bump_in_this_line( count );
   21|  3.69k|      }
   22|  3.69k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.38k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.38k|      else {
   20|  2.38k|         in.bump_in_this_line( count );
   21|  2.38k|      }
   22|  2.38k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.79k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.79k|      else {
   20|  2.79k|         in.bump_in_this_line( count );
   21|  2.79k|      }
   22|  2.79k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.87k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.87k|      else {
   20|  2.87k|         in.bump_in_this_line( count );
   21|  2.87k|      }
   22|  2.87k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.45k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.45k|      else {
   20|  2.45k|         in.bump_in_this_line( count );
   21|  2.45k|      }
   22|  2.45k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.25k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.25k|      else {
   20|  3.25k|         in.bump_in_this_line( count );
   21|  3.25k|      }
   22|  3.25k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.34k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.34k|      else {
   20|  2.34k|         in.bump_in_this_line( count );
   21|  2.34k|      }
   22|  2.34k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_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_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  23.2k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  23.2k|      else {
   20|  23.2k|         in.bump_in_this_line( count );
   21|  23.2k|      }
   22|  23.2k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.51k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.51k|      else {
   20|  4.51k|         in.bump_in_this_line( count );
   21|  4.51k|      }
   22|  4.51k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.25M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.25M|      else {
   20|  1.25M|         in.bump_in_this_line( count );
   21|  1.25M|      }
   22|  1.25M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.06M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.06M|      else {
   20|  1.06M|         in.bump_in_this_line( count );
   21|  1.06M|      }
   22|  1.06M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   354k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   354k|      else {
   20|   354k|         in.bump_in_this_line( count );
   21|   354k|      }
   22|   354k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   371k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   371k|      else {
   20|   371k|         in.bump_in_this_line( count );
   21|   371k|      }
   22|   371k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   412k|   {
   16|   412k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|   412k|         in.bump( count );
   18|       |      }
   19|       |      else {
   20|       |         in.bump_in_this_line( count );
   21|       |      }
   22|   412k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   119M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   119M|      else {
   20|   119M|         in.bump_in_this_line( count );
   21|   119M|      }
   22|   119M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.20k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.20k|      else {
   20|  4.20k|         in.bump_in_this_line( count );
   21|  4.20k|      }
   22|  4.20k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.14k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.14k|      else {
   20|  3.14k|         in.bump_in_this_line( count );
   21|  3.14k|      }
   22|  3.14k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.20k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.20k|      else {
   20|  3.20k|         in.bump_in_this_line( count );
   21|  3.20k|      }
   22|  3.20k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.96k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.96k|      else {
   20|  3.96k|         in.bump_in_this_line( count );
   21|  3.96k|      }
   22|  3.96k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.52k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.52k|      else {
   20|  3.52k|         in.bump_in_this_line( count );
   21|  3.52k|      }
   22|  3.52k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.17k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.17k|      else {
   20|  3.17k|         in.bump_in_this_line( count );
   21|  3.17k|      }
   22|  3.17k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  6.79k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  6.79k|      else {
   20|  6.79k|         in.bump_in_this_line( count );
   21|  6.79k|      }
   22|  6.79k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|    318|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    318|      else {
   20|    318|         in.bump_in_this_line( count );
   21|    318|      }
   22|    318|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   807k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   807k|      else {
   20|   807k|         in.bump_in_this_line( count );
   21|   807k|      }
   22|   807k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  25.8M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  25.8M|      else {
   20|  25.8M|         in.bump_in_this_line( count );
   21|  25.8M|      }
   22|  25.8M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  41.0k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  41.0k|      else {
   20|  41.0k|         in.bump_in_this_line( count );
   21|  41.0k|      }
   22|  41.0k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  41.0k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  41.0k|      else {
   20|  41.0k|         in.bump_in_this_line( count );
   21|  41.0k|      }
   22|  41.0k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc108ELc97ELc98ELc101ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.05k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.05k|      else {
   20|  4.05k|         in.bump_in_this_line( count );
   21|  4.05k|      }
   22|  4.05k|   }

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

_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|  80.2k|      {
   38|  80.2k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 13.2k, False: 67.0k]
  ------------------
   39|  13.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  13.2k|            return true;
   41|  13.2k|         }
   42|  67.0k|         return Default;
   43|  80.2k|      }
_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|   589k|      {
   38|   589k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 588k, False: 1.03k]
  ------------------
   39|   588k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   588k|            return true;
   41|   588k|         }
   42|  1.03k|         return Default;
   43|   589k|      }
_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|  17.4M|      {
   38|  17.4M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 245k, False: 17.1M]
  ------------------
   39|   245k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   245k|            return true;
   41|   245k|         }
   42|  17.1M|         return Default;
   43|  17.4M|      }
_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|   245k|      {
   38|   245k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 102k, False: 142k]
  ------------------
   39|   102k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   102k|            return true;
   41|   102k|         }
   42|   142k|         return Default;
   43|   245k|      }
_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|   142k|      {
   38|   142k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 39.2k, False: 103k]
  ------------------
   39|  39.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  39.2k|            return true;
   41|  39.2k|         }
   42|   103k|         return Default;
   43|   142k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  8.82k|      {
   38|  8.82k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 7.72k, False: 1.10k]
  ------------------
   39|  7.72k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  7.72k|            return true;
   41|  7.72k|         }
   42|  1.10k|         return Default;
   43|  8.82k|      }
_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|  12.0M|      {
   38|  12.0M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 176k, False: 11.9M]
  ------------------
   39|   176k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   176k|            return true;
   41|   176k|         }
   42|  11.9M|         return Default;
   43|  12.0M|      }
_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|   176k|      {
   38|   176k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 52.0k, False: 124k]
  ------------------
   39|  52.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  52.0k|            return true;
   41|  52.0k|         }
   42|   124k|         return Default;
   43|   176k|      }
_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|   124k|      {
   38|   124k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 64.7k, False: 59.8k]
  ------------------
   39|  64.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  64.7k|            return true;
   41|  64.7k|         }
   42|  59.8k|         return Default;
   43|   124k|      }
_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|  6.65k|      {
   38|  6.65k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.69k, False: 955]
  ------------------
   39|  5.69k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.69k|            return true;
   41|  5.69k|         }
   42|    955|         return Default;
   43|  6.65k|      }
_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|  9.96M|      {
   38|  9.96M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 131k, False: 9.83M]
  ------------------
   39|   131k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   131k|            return true;
   41|   131k|         }
   42|  9.83M|         return Default;
   43|  9.96M|      }
_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|   131k|      {
   38|   131k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 45.0k, False: 86.4k]
  ------------------
   39|  45.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  45.0k|            return true;
   41|  45.0k|         }
   42|  86.4k|         return Default;
   43|   131k|      }
_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|  86.4k|      {
   38|  86.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 27.4k, False: 59.0k]
  ------------------
   39|  27.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  27.4k|            return true;
   41|  27.4k|         }
   42|  59.0k|         return Default;
   43|  86.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|  5.51k|      {
   38|  5.51k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.95k, False: 562]
  ------------------
   39|  4.95k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.95k|            return true;
   41|  4.95k|         }
   42|    562|         return Default;
   43|  5.51k|      }
_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.66M|      {
   38|  2.66M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 8.36k, False: 2.66M]
  ------------------
   39|  8.36k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  8.36k|            return true;
   41|  8.36k|         }
   42|  2.66M|         return Default;
   43|  2.66M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|  8.36k|      {
   38|  8.36k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 3.01k, False: 5.34k]
  ------------------
   39|  3.01k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  3.01k|            return true;
   41|  3.01k|         }
   42|  5.34k|         return Default;
   43|  8.36k|      }
_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|  5.34k|      {
   38|  5.34k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 1.51k, False: 3.82k]
  ------------------
   39|  1.51k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  1.51k|            return true;
   41|  1.51k|         }
   42|  3.82k|         return Default;
   43|  5.34k|      }
_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|  7.73k|      {
   38|  7.73k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.35k, False: 1.38k]
  ------------------
   39|  6.35k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.35k|            return true;
   41|  6.35k|         }
   42|  1.38k|         return Default;
   43|  7.73k|      }
_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|  9.02M|      {
   38|  9.02M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 97.4k, False: 8.92M]
  ------------------
   39|  97.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  97.4k|            return true;
   41|  97.4k|         }
   42|  8.92M|         return Default;
   43|  9.02M|      }
_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|  97.4k|      {
   38|  97.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 28.2k, False: 69.2k]
  ------------------
   39|  28.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  28.2k|            return true;
   41|  28.2k|         }
   42|  69.2k|         return Default;
   43|  97.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|  69.2k|      {
   38|  69.2k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 29.7k, False: 39.4k]
  ------------------
   39|  29.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  29.7k|            return true;
   41|  29.7k|         }
   42|  39.4k|         return Default;
   43|  69.2k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.96k|      {
   38|  5.96k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.03k, False: 930]
  ------------------
   39|  5.03k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.03k|            return true;
   41|  5.03k|         }
   42|    930|         return Default;
   43|  5.96k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.46M|      {
   38|  7.46M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 75.4k, False: 7.38M]
  ------------------
   39|  75.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  75.4k|            return true;
   41|  75.4k|         }
   42|  7.38M|         return Default;
   43|  7.46M|      }
_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|  75.4k|      {
   38|  75.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 19.0k, False: 56.4k]
  ------------------
   39|  19.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  19.0k|            return true;
   41|  19.0k|         }
   42|  56.4k|         return Default;
   43|  75.4k|      }
_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|  56.4k|      {
   38|  56.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 24.6k, False: 31.8k]
  ------------------
   39|  24.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  24.6k|            return true;
   41|  24.6k|         }
   42|  31.8k|         return Default;
   43|  56.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|   807k|      {
   38|   807k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 41.0k, False: 766k]
  ------------------
   39|  41.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  41.0k|            return true;
   41|  41.0k|         }
   42|   766k|         return Default;
   43|   807k|      }
_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|  53.2M|      {
   38|  53.2M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 163k, False: 53.1M]
  ------------------
   39|   163k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   163k|            return true;
   41|   163k|         }
   42|  53.1M|         return Default;
   43|  53.2M|      }
_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|   163k|      {
   38|   163k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 51.5k, False: 111k]
  ------------------
   39|  51.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  51.5k|            return true;
   41|  51.5k|         }
   42|   111k|         return Default;
   43|   163k|      }
_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|   111k|      {
   38|   111k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 26.3k, False: 85.2k]
  ------------------
   39|  26.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  26.3k|            return true;
   41|  26.3k|         }
   42|  85.2k|         return Default;
   43|   111k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.44k|      {
   38|  7.44k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.53k, False: 917]
  ------------------
   39|  6.53k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.53k|            return true;
   41|  6.53k|         }
   42|    917|         return Default;
   43|  7.44k|      }
_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|  8.59M|      {
   38|  8.59M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 163k, False: 8.43M]
  ------------------
   39|   163k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   163k|            return true;
   41|   163k|         }
   42|  8.43M|         return Default;
   43|  8.59M|      }
_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|   163k|      {
   38|   163k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 53.1k, False: 110k]
  ------------------
   39|  53.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  53.1k|            return true;
   41|  53.1k|         }
   42|   110k|         return Default;
   43|   163k|      }
_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|   110k|      {
   38|   110k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 70.1k, False: 40.3k]
  ------------------
   39|  70.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  70.1k|            return true;
   41|  70.1k|         }
   42|  40.3k|         return Default;
   43|   110k|      }

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

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

_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEC2ERKS3_:
   19|   668M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEC2ERS3_:
   42|  9.45M|         : m_saved( i ),
   43|  9.45M|           m_input( &i )
   44|  9.45M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEclEb:
   60|  6.81M|      {
   61|  6.81M|         if( result ) {
  ------------------
  |  Branch (61:14): [True: 6.01M, False: 794k]
  ------------------
   62|  6.01M|            m_input = nullptr;
   63|  6.01M|            return true;
   64|  6.01M|         }
   65|   794k|         return false;
   66|  6.81M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EE8iteratorEv:
   69|  2.48M|      {
   70|  2.48M|         return m_saved;
   71|  2.48M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEC2ERKS3_:
   19|  2.86M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEclEb:
   30|  2.85M|      {
   31|  2.85M|         return result;
   32|  2.85M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EED2Ev:
   50|  9.45M|      {
   51|  9.45M|         if( m_input != nullptr ) {
  ------------------
  |  Branch (51:14): [True: 3.43M, False: 6.01M]
  ------------------
   52|  3.43M|            ( *m_input ) = m_saved;
   53|  3.43M|         }
   54|  9.45M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEclEb:
   30|   668M|      {
   31|   668M|         return result;
   32|   668M|      }

_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|  13.2k|      {
   56|  13.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 13.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  13.2k|         return true;
   60|  13.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   588k|      {
   56|   588k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 219, False: 588k]
  ------------------
   57|    219|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    219|         }
   59|   588k|         return true;
   60|   588k|      }
_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|   245k|      {
   56|   245k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 63, False: 245k]
  ------------------
   57|     63|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     63|         }
   59|   245k|         return true;
   60|   245k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|   102k|      {
   56|   102k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 102k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|   102k|         return true;
   60|   102k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  39.2k|      {
   56|  39.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 39.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  39.2k|         return true;
   60|  39.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  7.72k|      {
   56|  7.72k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 202, False: 7.52k]
  ------------------
   57|    202|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    202|         }
   59|  7.72k|         return true;
   60|  7.72k|      }
_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|   176k|      {
   56|   176k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 57, False: 176k]
  ------------------
   57|     57|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     57|         }
   59|   176k|         return true;
   60|   176k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  52.0k|      {
   56|  52.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 45, False: 52.0k]
  ------------------
   57|     45|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     45|         }
   59|  52.0k|         return true;
   60|  52.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  64.7k|      {
   56|  64.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 64.7k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  64.7k|         return true;
   60|  64.7k|      }
_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.69k|      {
   56|  5.69k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 177, False: 5.51k]
  ------------------
   57|    177|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    177|         }
   59|  5.69k|         return true;
   60|  5.69k|      }
_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|   131k|      {
   56|   131k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 52, False: 131k]
  ------------------
   57|     52|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     52|         }
   59|   131k|         return true;
   60|   131k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  45.0k|      {
   56|  45.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 32, False: 44.9k]
  ------------------
   57|     32|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     32|         }
   59|  45.0k|         return true;
   60|  45.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|  27.4k|      {
   56|  27.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 27.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  27.4k|         return true;
   60|  27.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.95k|      {
   56|  4.95k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 159, False: 4.79k]
  ------------------
   57|    159|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    159|         }
   59|  4.95k|         return true;
   60|  4.95k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  8.36k|      {
   56|  8.36k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 28, False: 8.33k]
  ------------------
   57|     28|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     28|         }
   59|  8.36k|         return true;
   60|  8.36k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  3.01k|      {
   56|  3.01k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 24, False: 2.99k]
  ------------------
   57|     24|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     24|         }
   59|  3.01k|         return true;
   60|  3.01k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  1.51k|      {
   56|  1.51k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 1.51k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  1.51k|         return true;
   60|  1.51k|      }
_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|  6.35k|      {
   56|  6.35k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 192, False: 6.15k]
  ------------------
   57|    192|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    192|         }
   59|  6.35k|         return true;
   60|  6.35k|      }
_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|  97.4k|      {
   56|  97.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 61, False: 97.3k]
  ------------------
   57|     61|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     61|         }
   59|  97.4k|         return true;
   60|  97.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|  28.2k|      {
   56|  28.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 24, False: 28.1k]
  ------------------
   57|     24|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     24|         }
   59|  28.2k|         return true;
   60|  28.2k|      }
_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|  29.7k|      {
   56|  29.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 29.7k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  29.7k|         return true;
   60|  29.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.03k|      {
   56|  5.03k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 177, False: 4.85k]
  ------------------
   57|    177|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    177|         }
   59|  5.03k|         return true;
   60|  5.03k|      }
_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|  75.4k|      {
   56|  75.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 44, False: 75.4k]
  ------------------
   57|     44|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     44|         }
   59|  75.4k|         return true;
   60|  75.4k|      }
_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|  19.0k|      {
   56|  19.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 35, False: 19.0k]
  ------------------
   57|     35|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     35|         }
   59|  19.0k|         return true;
   60|  19.0k|      }
_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|  24.6k|      {
   56|  24.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 24.6k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  24.6k|         return true;
   60|  24.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  41.0k|      {
   56|  41.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 289, False: 40.7k]
  ------------------
   57|    289|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    289|         }
   59|  41.0k|         return true;
   60|  41.0k|      }
_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|   163k|      {
   56|   163k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 66, False: 162k]
  ------------------
   57|     66|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     66|         }
   59|   163k|         return true;
   60|   163k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  51.5k|      {
   56|  51.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 45, False: 51.4k]
  ------------------
   57|     45|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     45|         }
   59|  51.5k|         return true;
   60|  51.5k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  26.3k|      {
   56|  26.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 26.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  26.3k|         return true;
   60|  26.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.53k|      {
   56|  6.53k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 187, False: 6.34k]
  ------------------
   57|    187|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    187|         }
   59|  6.53k|         return true;
   60|  6.53k|      }
_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|   163k|      {
   56|   163k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 60, False: 163k]
  ------------------
   57|     60|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     60|         }
   59|   163k|         return true;
   60|   163k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  53.1k|      {
   56|  53.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 41, False: 53.1k]
  ------------------
   57|     41|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     41|         }
   59|  53.1k|         return true;
   60|  53.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  70.1k|      {
   56|  70.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 70.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  70.1k|         return true;
   60|  70.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   55|  37.9k|      {
   56|  37.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.58k, False: 33.3k]
  ------------------
   57|  4.58k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.58k|         }
   59|  37.9k|         return true;
   60|  37.9k|      }

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

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  6.85M|      {
   41|  6.85M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 6.77M, False: 77.6k]
  ------------------
   42|  6.77M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 4.09M, False: 2.68M]
  ------------------
   43|  4.09M|               bump_help< one >( in, t.size );
   44|  4.09M|               return true;
   45|  4.09M|            }
   46|  6.77M|         }
   47|  2.76M|         return false;
   48|  6.85M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  6.77M|      {
   32|  9.53M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 4.01M, False: 2.75M]
  |  Branch (32:19): [True: 74.4k, False: 2.68M]
  ------------------
   33|  6.77M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  80.2k|      {
   41|  80.2k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 60.1k, False: 20.1k]
  ------------------
   42|  60.1k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 13.2k, False: 46.9k]
  ------------------
   43|  13.2k|               bump_help< one >( in, t.size );
   44|  13.2k|               return true;
   45|  13.2k|            }
   46|  60.1k|         }
   47|  67.0k|         return false;
   48|  80.2k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  60.1k|      {
   32|  60.1k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  60.1k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.77M|      {
   41|  1.77M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.77M, False: 949]
  ------------------
   42|  1.77M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.73M, False: 39.4k]
  ------------------
   43|  1.73M|               bump_help< one >( in, t.size );
   44|  1.73M|               return true;
   45|  1.73M|            }
   46|  1.77M|         }
   47|  40.4k|         return false;
   48|  1.77M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  1.77M|      {
   32|  1.77M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.77M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.12M|      {
   41|  1.12M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.12M, False: 44]
  ------------------
   42|  1.12M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.12M, False: 90]
  ------------------
   43|  1.12M|               bump_help< one >( in, t.size );
   44|  1.12M|               return true;
   45|  1.12M|            }
   46|  1.12M|         }
   47|    134|         return false;
   48|  1.12M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|  1.12M|      {
   32|  1.12M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.12M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  40.0k|      {
   41|  40.0k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 39.6k, False: 443]
  ------------------
   42|  39.6k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 26.9k, False: 12.6k]
  ------------------
   43|  26.9k|               bump_help< one >( in, t.size );
   44|  26.9k|               return true;
   45|  26.9k|            }
   46|  39.6k|         }
   47|  13.0k|         return false;
   48|  40.0k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  39.6k|      {
   32|  39.6k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  39.6k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  25.0k|      {
   41|  25.0k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 23.9k, False: 1.17k]
  ------------------
   42|  23.9k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 23.2k, False: 697]
  ------------------
   43|  23.2k|               bump_help< one >( in, t.size );
   44|  23.2k|               return true;
   45|  23.2k|            }
   46|  23.9k|         }
   47|  1.87k|         return false;
   48|  25.0k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  23.9k|      {
   32|  23.9k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  23.9k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  68.5M|      {
   41|  68.5M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 68.5M, False: 1.95k]
  ------------------
   42|  68.5M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.25M, False: 67.2M]
  ------------------
   43|  1.25M|               bump_help< one >( in, t.size );
   44|  1.25M|               return true;
   45|  1.25M|            }
   46|  68.5M|         }
   47|  67.2M|         return false;
   48|  68.5M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  68.5M|      {
   32|  68.5M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  68.5M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   120M|      {
   41|   120M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 120M, False: 1.57k]
  ------------------
   42|   120M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.06M, False: 119M]
  ------------------
   43|  1.06M|               bump_help< one >( in, t.size );
   44|  1.06M|               return true;
   45|  1.06M|            }
   46|   120M|         }
   47|   119M|         return false;
   48|   120M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|   120M|      {
   32|   120M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   120M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.06M|      {
   41|  1.06M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.06M, False: 100]
  ------------------
   42|  1.06M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 354k, False: 706k]
  ------------------
   43|   354k|               bump_help< one >( in, t.size );
   44|   354k|               return true;
   45|   354k|            }
   46|  1.06M|         }
   47|   706k|         return false;
   48|  1.06M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|  1.06M|      {
   32|  1.06M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.06M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   423k|      {
   41|   423k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 423k, False: 100]
  ------------------
   42|   423k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 412k, False: 10.3k]
  ------------------
   43|   412k|               bump_help< one >( in, t.size );
   44|   412k|               return true;
   45|   412k|            }
   46|   423k|         }
   47|  10.4k|         return false;
   48|   423k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   423k|      {
   32|  3.67M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 36.1k]
  |  Branch (32:19): [True: 25.7k, False: 10.3k]
  |  Branch (32:19): [True: 27.4k, False: 36.1k]
  |  Branch (32:19): [True: 57.8k, False: 63.6k]
  |  Branch (32:19): [True: 13.0k, False: 121k]
  |  Branch (32:19): [True: 25.1k, False: 134k]
  |  Branch (32:19): [True: 37.3k, False: 159k]
  |  Branch (32:19): [True: 28.2k, False: 197k]
  |  Branch (32:19): [True: 69.3k, False: 225k]
  |  Branch (32:19): [True: 81.7k, False: 294k]
  |  Branch (32:19): [True: 46.6k, False: 376k]
  ------------------
   33|   423k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   119M|      {
   41|   119M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 119M, False: 1.57k]
  ------------------
   42|   119M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 119M, False: 28]
  ------------------
   43|   119M|               bump_help< one >( in, t.size );
   44|   119M|               return true;
   45|   119M|            }
   46|   119M|         }
   47|  1.60k|         return false;
   48|   119M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|   119M|      {
   32|   238M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 13, False: 119M]
  |  Branch (32:19): [True: 15, False: 119M]
  ------------------
   33|   119M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   808k|      {
   41|   808k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 808k, False: 114]
  ------------------
   42|   808k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 318, False: 808k]
  ------------------
   43|    318|               bump_help< one >( in, t.size );
   44|    318|               return true;
   45|    318|            }
   46|   808k|         }
   47|   808k|         return false;
   48|   808k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   808k|      {
   32|   808k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   808k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   807k|      {
   41|   807k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 806k, False: 1.12k]
  ------------------
   42|   806k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 41.0k, False: 765k]
  ------------------
   43|  41.0k|               bump_help< one >( in, t.size );
   44|  41.0k|               return true;
   45|  41.0k|            }
   46|   806k|         }
   47|   766k|         return false;
   48|   807k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   806k|      {
   32|   806k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   806k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  53.3M|      {
   41|  53.3M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 53.3M, False: 296]
  ------------------
   42|  53.3M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 41.0k, False: 53.2M]
  ------------------
   43|  41.0k|               bump_help< one >( in, t.size );
   44|  41.0k|               return true;
   45|  41.0k|            }
   46|  53.3M|         }
   47|  53.2M|         return false;
   48|  53.3M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  53.3M|      {
   32|  53.3M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  53.3M|      }

_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|  42.5k|      {
   47|  42.5k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  42.5k|         return true;
   49|  42.5k|      }
_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|  42.3k|      {
   47|  42.3k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  42.3k|         return true;
   49|  42.3k|      }
_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|  42.3k|      {
   47|  42.3k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  42.3k|         return true;
   49|  42.3k|      }
_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.67k|      {
   47|  3.67k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.67k|         return true;
   49|  3.67k|      }
_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.49k|      {
   47|  4.49k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.49k|         return true;
   49|  4.49k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.18k|      {
   47|  4.18k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.18k|         return true;
   49|  4.18k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.12k|      {
   47|  3.12k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.12k|         return true;
   49|  3.12k|      }
_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.18k|      {
   47|  3.18k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.18k|         return true;
   49|  3.18k|      }
_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.94k|      {
   47|  3.94k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.94k|         return true;
   49|  3.94k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.51k|      {
   47|  3.51k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.51k|         return true;
   49|  3.51k|      }
_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|  3.16k|      {
   47|  3.16k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.16k|         return true;
   49|  3.16k|      }
_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|  6.76k|      {
   47|  6.76k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  6.76k|         return true;
   49|  6.76k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   808k|      {
   47|   808k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   808k|         return true;
   49|   808k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   807k|      {
   47|   807k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   807k|         return true;
   49|   807k|      }
_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.03k|      {
   47|  4.03k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.03k|         return true;
   49|  4.03k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  37.7k|      {
   47|  37.7k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  37.7k|         return true;
   49|  37.7k|      }

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

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   116k|      {
   46|   116k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 87.5k, False: 28.8k]
  ------------------
   47|  96.9k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 9.39k, False: 87.5k]
  ------------------
   48|  9.39k|            }
   49|  87.5k|            return true;
   50|  87.5k|         }
   51|  28.8k|         return false;
   52|   116k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   796k|      {
   46|   796k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 795k, False: 1.23k]
  ------------------
   47|   799k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 4.21k, False: 795k]
  ------------------
   48|  4.21k|            }
   49|   795k|            return true;
   50|   795k|         }
   51|  1.23k|         return false;
   52|   796k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   594k|      {
   46|   594k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 591k, False: 2.83k]
  ------------------
   47|   595k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.91k, False: 591k]
  ------------------
   48|  3.91k|            }
   49|   591k|            return true;
   50|   591k|         }
   51|  2.83k|         return false;
   52|   594k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  12.6k|      {
   46|  12.6k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 10.4k, False: 2.22k]
  ------------------
   47|  12.5k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.12k, False: 10.4k]
  ------------------
   48|  2.12k|            }
   49|  10.4k|            return true;
   50|  10.4k|         }
   51|  2.22k|         return false;
   52|  12.6k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.89k|      {
   46|  8.89k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.47k, False: 1.41k]
  ------------------
   47|  9.46k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.99k, False: 7.47k]
  ------------------
   48|  1.99k|            }
   49|  7.47k|            return true;
   50|  7.47k|         }
   51|  1.41k|         return false;
   52|  8.89k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.27k|      {
   46|  8.27k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.71k, False: 1.55k]
  ------------------
   47|  9.82k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.11k, False: 6.71k]
  ------------------
   48|  3.11k|            }
   49|  6.71k|            return true;
   50|  6.71k|         }
   51|  1.55k|         return false;
   52|  8.27k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.7k|      {
   46|  10.7k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 9.04k, False: 1.71k]
  ------------------
   47|  11.9k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.91k, False: 9.04k]
  ------------------
   48|  2.91k|            }
   49|  9.04k|            return true;
   50|  9.04k|         }
   51|  1.71k|         return false;
   52|  10.7k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   167k|      {
   46|   167k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 166k, False: 1.68k]
  ------------------
   47|  1.63M|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.46M, False: 166k]
  ------------------
   48|  1.46M|            }
   49|   166k|            return true;
   50|   166k|         }
   51|  1.68k|         return false;
   52|   167k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.01k|      {
   46|  9.01k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.03k, False: 1.97k]
  ------------------
   47|  10.5k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.53k, False: 7.03k]
  ------------------
   48|  3.53k|            }
   49|  7.03k|            return true;
   50|  7.03k|         }
   51|  1.97k|         return false;
   52|  9.01k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   812k|      {
   46|   812k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 809k, False: 2.64k]
  ------------------
   47|   848k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 38.9k, False: 809k]
  ------------------
   48|  38.9k|            }
   49|   809k|            return true;
   50|   809k|         }
   51|  2.64k|         return false;
   52|   812k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.1k|      {
   46|  10.1k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.48k, False: 1.70k]
  ------------------
   47|  10.2k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.72k, False: 8.48k]
  ------------------
   48|  1.72k|            }
   49|  8.48k|            return true;
   50|  8.48k|         }
   51|  1.70k|         return false;
   52|  10.1k|      }

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

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  3.19M|      {
   60|  3.19M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 3.18M, False: 1.22k]
  ------------------
   61|  3.18M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 1.41M, False: 1.77M]
  ------------------
   62|  1.41M|               bump_help< ranges >( in, t.size );
   63|  1.41M|               return true;
   64|  1.41M|            }
   65|  3.18M|         }
   66|  1.77M|         return false;
   67|  3.19M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  3.18M|      {
   51|  3.18M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  3.18M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  3.18M|      {
   40|  3.18M|         constexpr const data_t cs[] = { Cs... };
   41|  3.18M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|  11.3M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 399k, False: 2.45M]
  |  Branch (42:22): [True: 673k, False: 1.77M]
  |  Branch (42:22): [True: 337k, False: 2.85M]
  ------------------
   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.18M|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc48ETnS3_Lc57EEEbS3_:
   23|  4.17M|   {
   24|  4.17M|      static_assert( Lo <= Hi, "invalid range" );
   25|  4.17M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 1.46M, False: 2.71M]
  |  Branch (25:29): [True: 352k, False: 1.11M]
  ------------------
   26|  4.17M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc102EEEbS3_:
   23|  2.85M|   {
   24|  2.85M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.85M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 438k, False: 2.41M]
  |  Branch (25:29): [True: 399k, False: 39.0k]
  ------------------
   26|  2.85M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc70EEEbS3_:
   23|  2.45M|   {
   24|  2.45M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.45M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 713k, False: 1.73M]
  |  Branch (25:29): [True: 673k, False: 39.1k]
  ------------------
   26|  2.45M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   808k|      {
   60|   808k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 808k, False: 119]
  ------------------
   61|   808k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 807k, False: 1.07k]
  ------------------
   62|   807k|               bump_help< ranges >( in, t.size );
   63|   807k|               return true;
   64|   807k|            }
   65|   808k|         }
   66|  1.19k|         return false;
   67|   808k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   808k|      {
   51|   808k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   808k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   808k|      {
   40|   808k|         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|   808k|         else {
   45|  1.61M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 807k, False: 1.15k]
  |  Branch (45:22): [True: 44, False: 1.11k]
  |  Branch (45:96): [True: 36, False: 1.07k]
  ------------------
   46|   808k|         }
   47|   808k|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc122EEEbS3_:
   23|  27.4M|   {
   24|  27.4M|      static_assert( Lo <= Hi, "invalid range" );
   25|  27.4M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.86M, False: 21.5M]
  |  Branch (25:29): [True: 5.86M, False: 2.99k]
  ------------------
   26|  27.4M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc90EEEbS3_:
   23|  21.5M|   {
   24|  21.5M|      static_assert( Lo <= Hi, "invalid range" );
   25|  21.5M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 20.5M, False: 987k]
  |  Branch (25:29): [True: 20.5M, False: 3.00k]
  ------------------
   26|  21.5M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  26.6M|      {
   60|  26.6M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 26.6M, False: 1.12k]
  ------------------
   61|  26.6M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 25.8M, False: 806k]
  ------------------
   62|  25.8M|               bump_help< ranges >( in, t.size );
   63|  25.8M|               return true;
   64|  25.8M|            }
   65|  26.6M|         }
   66|   807k|         return false;
   67|  26.6M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  26.6M|      {
   51|  26.6M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  26.6M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  26.6M|      {
   40|  26.6M|         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|  26.6M|         else {
   45|  97.4M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 20.5M, False: 989k]
  |  Branch (45:22): [True: 14.7k, False: 974k]
  |  Branch (45:22): [True: 5.05M, False: 21.5M]
  |  Branch (45:96): [True: 168k, False: 806k]
  ------------------
   46|  26.6M|         }
   47|  26.6M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  45.9k|      {
   50|  45.9k|         auto m = in.template mark< M >();
   51|  45.9k|         using m_t = decltype( m );
   52|       |
   53|  62.0k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 58.0k, False: 4.00k]
  ------------------
   54|  58.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41.9k, False: 16.0k]
  ------------------
   55|  41.9k|               return false;
   56|  41.9k|            }
   57|  58.0k|         }
   58|  4.00k|         return m( true );
   59|  45.9k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.58M|      {
   50|  1.58M|         auto m = in.template mark< M >();
   51|  1.58M|         using m_t = decltype( m );
   52|       |
   53|  1.59M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.59M, False: 2.68k]
  ------------------
   54|  1.59M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.58M, False: 10.9k]
  ------------------
   55|  1.58M|               return false;
   56|  1.58M|            }
   57|  1.59M|         }
   58|  2.68k|         return m( true );
   59|  1.58M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   102k|      {
   50|   102k|         auto m = in.template mark< M >();
   51|   102k|         using m_t = decltype( m );
   52|       |
   53|   307k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 205k, False: 102k]
  ------------------
   54|   205k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 205k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|   205k|         }
   58|   102k|         return m( true );
   59|   102k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  52.0k|      {
   50|  52.0k|         auto m = in.template mark< M >();
   51|  52.0k|         using m_t = decltype( m );
   52|       |
   53|   156k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 104k, False: 52.0k]
  ------------------
   54|   104k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 45, False: 104k]
  ------------------
   55|     45|               return false;
   56|     45|            }
   57|   104k|         }
   58|  52.0k|         return m( true );
   59|  52.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  45.0k|      {
   50|  45.0k|         auto m = in.template mark< M >();
   51|  45.0k|         using m_t = decltype( m );
   52|       |
   53|   134k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 89.9k, False: 44.9k]
  ------------------
   54|  89.9k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 32, False: 89.9k]
  ------------------
   55|     32|               return false;
   56|     32|            }
   57|  89.9k|         }
   58|  44.9k|         return m( true );
   59|  45.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  3.01k|      {
   50|  3.01k|         auto m = in.template mark< M >();
   51|  3.01k|         using m_t = decltype( m );
   52|       |
   53|  9.02k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 6.02k, False: 2.99k]
  ------------------
   54|  6.02k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 24, False: 6.00k]
  ------------------
   55|     24|               return false;
   56|     24|            }
   57|  6.02k|         }
   58|  2.99k|         return m( true );
   59|  3.01k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  28.2k|      {
   50|  28.2k|         auto m = in.template mark< M >();
   51|  28.2k|         using m_t = decltype( m );
   52|       |
   53|  84.5k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 56.3k, False: 28.1k]
  ------------------
   54|  56.3k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 24, False: 56.3k]
  ------------------
   55|     24|               return false;
   56|     24|            }
   57|  56.3k|         }
   58|  28.1k|         return m( true );
   59|  28.2k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   164k|      {
   50|   164k|         auto m = in.template mark< M >();
   51|   164k|         using m_t = decltype( m );
   52|       |
   53|   491k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 327k, False: 163k]
  ------------------
   54|   327k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.15k, False: 326k]
  ------------------
   55|  1.15k|               return false;
   56|  1.15k|            }
   57|   327k|         }
   58|   163k|         return m( true );
   59|   164k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   326k|      {
   50|   326k|         auto m = in.template mark< M >();
   51|   326k|         using m_t = decltype( m );
   52|       |
   53|   674k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 500k, False: 174k]
  ------------------
   54|   500k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 152k, False: 348k]
  ------------------
   55|   152k|               return false;
   56|   152k|            }
   57|   500k|         }
   58|   174k|         return m( true );
   59|   326k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  19.0k|      {
   50|  19.0k|         auto m = in.template mark< M >();
   51|  19.0k|         using m_t = decltype( m );
   52|       |
   53|  57.1k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 38.1k, False: 19.0k]
  ------------------
   54|  38.1k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 35, False: 38.0k]
  ------------------
   55|     35|               return false;
   56|     35|            }
   57|  38.1k|         }
   58|  19.0k|         return m( true );
   59|  19.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  51.5k|      {
   50|  51.5k|         auto m = in.template mark< M >();
   51|  51.5k|         using m_t = decltype( m );
   52|       |
   53|   154k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 102k, False: 51.4k]
  ------------------
   54|   102k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 45, False: 102k]
  ------------------
   55|     45|               return false;
   56|     45|            }
   57|   102k|         }
   58|  51.4k|         return m( true );
   59|  51.5k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  53.1k|      {
   50|  53.1k|         auto m = in.template mark< M >();
   51|  53.1k|         using m_t = decltype( m );
   52|       |
   53|   159k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 106k, False: 53.1k]
  ------------------
   54|   106k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41, False: 106k]
  ------------------
   55|     41|               return false;
   56|     41|            }
   57|   106k|         }
   58|  53.1k|         return m( true );
   59|  53.1k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  39.2k|      {
   50|  46.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 44.1k, False: 2.54k]
  |  Branch (50:47): [True: 7.49k, False: 36.7k]
  ------------------
   51|  7.49k|         }
   52|  39.2k|         return true;
   53|  39.2k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  64.7k|      {
   50|  80.0k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 73.7k, False: 6.34k]
  |  Branch (50:47): [True: 15.3k, False: 58.3k]
  ------------------
   51|  15.3k|         }
   52|  64.7k|         return true;
   53|  64.7k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  27.4k|      {
   50|  54.8k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 42.4k, False: 12.3k]
  |  Branch (50:47): [True: 27.3k, False: 15.0k]
  ------------------
   51|  27.3k|         }
   52|  27.4k|         return true;
   53|  27.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.51k|      {
   50|  2.33k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 1.96k, False: 374]
  |  Branch (50:47): [True: 816, False: 1.14k]
  ------------------
   51|    816|         }
   52|  1.51k|         return true;
   53|  1.51k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  29.7k|      {
   50|  38.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 35.3k, False: 3.37k]
  |  Branch (50:47): [True: 9.02k, False: 26.3k]
  ------------------
   51|  9.02k|         }
   52|  29.7k|         return true;
   53|  29.7k|      }
_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|  24.6k|      {
   50|  30.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 28.8k, False: 1.76k]
  |  Branch (50:47): [True: 6.00k, False: 22.8k]
  ------------------
   51|  6.00k|         }
   52|  24.6k|         return true;
   53|  24.6k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  26.3k|      {
   50|  33.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 31.3k, False: 2.37k]
  |  Branch (50:47): [True: 7.39k, False: 23.9k]
  ------------------
   51|  7.39k|         }
   52|  26.3k|         return true;
   53|  26.3k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  70.1k|      {
   50|  84.2k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 78.0k, False: 6.23k]
  |  Branch (50:47): [True: 14.1k, False: 63.8k]
  ------------------
   51|  14.1k|         }
   52|  70.1k|         return true;
   53|  70.1k|      }

_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|  42.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.5k|         else {
   46|  42.5k|            auto m = in.template mark< M >();
   47|  42.5k|            using m_t = decltype( m );
   48|   165k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 37.9k, False: 4.61k]
  |  Branch (48:25): [True: 33.3k, False: 4.58k]
  |  Branch (48:25): [True: 42.5k, False: 0]
  ------------------
   49|  42.5k|         }
   50|  42.5k|      }
_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|  80.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  80.2k|         else {
   46|  80.2k|            auto m = in.template mark< M >();
   47|  80.2k|            using m_t = decltype( m );
   48|   160k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 80.2k, False: 0]
  |  Branch (48:25): [True: 13.2k, False: 67.0k]
  ------------------
   49|  80.2k|         }
   50|  80.2k|      }
_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|   834k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   834k|         else {
   46|   834k|            auto m = in.template mark< M >();
   47|   834k|            using m_t = decltype( m );
   48|  1.65M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 821k, False: 13.2k]
  |  Branch (48:25): [True: 821k, False: 0]
  ------------------
   49|   834k|         }
   50|   834k|      }
_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|  42.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.4k|         else {
   46|  42.4k|            auto m = in.template mark< M >();
   47|  42.4k|            using m_t = decltype( m );
   48|   325k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 37.7k, False: 0]
  |  Branch (48:25): [True: 37.7k, False: 0]
  |  Branch (48:25): [True: 37.7k, False: 4.61k]
  |  Branch (48:25): [True: 42.3k, False: 4]
  |  Branch (48:25): [True: 42.3k, False: 108]
  ------------------
   49|  42.4k|         }
   50|  42.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  42.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.3k|         else {
   46|  42.3k|            auto m = in.template mark< M >();
   47|  42.3k|            using m_t = decltype( m );
   48|  84.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 42.3k, False: 26]
  |  Branch (48:25): [True: 3.56k, False: 38.7k]
  ------------------
   49|  42.3k|         }
   50|  42.3k|      }
_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|  42.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.3k|         else {
   46|  42.3k|            auto m = in.template mark< M >();
   47|  42.3k|            using m_t = decltype( m );
   48|  53.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.58k, False: 28]
  |  Branch (48:25): [True: 3.56k, False: 11]
  |  Branch (48:25): [True: 3.60k, False: 38.7k]
  ------------------
   49|  42.3k|         }
   50|  42.3k|      }
_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|  42.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.3k|         else {
   46|  42.3k|            auto m = in.template mark< M >();
   47|  42.3k|            using m_t = decltype( m );
   48|  82.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 39.6k, False: 2.70k]
  |  Branch (48:25): [True: 28.3k, False: 11.3k]
  ------------------
   49|  42.3k|         }
   50|  42.3k|      }
_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|  39.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  39.6k|         else {
   46|  39.6k|            auto m = in.template mark< M >();
   47|  39.6k|            using m_t = decltype( m );
   48|  68.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 28.6k, False: 11.0k]
  |  Branch (48:25): [True: 28.3k, False: 297]
  ------------------
   49|  39.6k|         }
   50|  39.6k|      }
_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|  45.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  45.2k|         else {
   46|  45.2k|            auto m = in.template mark< M >();
   47|  45.2k|            using m_t = decltype( m );
   48|  56.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.67k, False: 21]
  |  Branch (48:25): [True: 3.21k, False: 458]
  |  Branch (48:25): [True: 3.69k, False: 41.5k]
  ------------------
   49|  45.2k|         }
   50|  45.2k|      }
_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.67k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.67k|         else {
   46|  3.67k|            auto m = in.template mark< M >();
   47|  3.67k|            using m_t = decltype( m );
   48|  27.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.33k, False: 0]
  |  Branch (48:25): [True: 2.16k, False: 166]
  |  Branch (48:25): [True: 2.33k, False: 69]
  |  Branch (48:25): [True: 2.40k, False: 0]
  |  Branch (48:25): [True: 2.40k, False: 1.27k]
  |  Branch (48:25): [True: 3.67k, False: 0]
  ------------------
   49|  3.67k|         }
   50|  3.67k|      }
_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.67k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.67k|         else {
   46|  3.67k|            auto m = in.template mark< M >();
   47|  3.67k|            using m_t = decltype( m );
   48|  5.32k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.65k, False: 2.02k]
  |  Branch (48:25): [True: 1.60k, False: 43]
  ------------------
   49|  3.67k|         }
   50|  3.67k|      }
_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.40k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.40k|         else {
   46|  2.40k|            auto m = in.template mark< M >();
   47|  2.40k|            using m_t = decltype( m );
   48|  4.73k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.33k, False: 66]
  |  Branch (48:25): [True: 2.33k, False: 3]
  ------------------
   49|  2.40k|         }
   50|  2.40k|      }
_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|   791k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   791k|         else {
   46|   791k|            auto m = in.template mark< M >();
   47|   791k|            using m_t = decltype( m );
   48|  1.58M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 790k, False: 1.16k]
  |  Branch (48:25): [True: 789k, False: 1.17k]
  ------------------
   49|   791k|         }
   50|   791k|      }
_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|   794k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   794k|         else {
   46|   794k|            auto m = in.template mark< M >();
   47|   794k|            using m_t = decltype( m );
   48|  3.17M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 792k, False: 44]
  |  Branch (48:25): [True: 792k, False: 20]
  |  Branch (48:25): [True: 792k, False: 1.62k]
  ------------------
   49|   794k|         }
   50|   794k|      }
_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|  42.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  42.0k|         else {
   46|  42.0k|            auto m = in.template mark< M >();
   47|  42.0k|            using m_t = decltype( m );
   48|  55.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.49k, False: 15]
  |  Branch (48:25): [True: 3.77k, False: 722]
  |  Branch (48:25): [True: 4.51k, False: 37.5k]
  ------------------
   49|  42.0k|         }
   50|  42.0k|      }
_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.49k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.49k|         else {
   46|  4.49k|            auto m = in.template mark< M >();
   47|  4.49k|            using m_t = decltype( m );
   48|  37.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.44k, False: 0]
  |  Branch (48:25): [True: 3.30k, False: 140]
  |  Branch (48:25): [True: 3.44k, False: 74]
  |  Branch (48:25): [True: 3.51k, False: 0]
  |  Branch (48:25): [True: 3.51k, False: 982]
  |  Branch (48:25): [True: 4.49k, False: 0]
  ------------------
   49|  4.49k|         }
   50|  4.49k|      }
_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.49k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.49k|         else {
   46|  4.49k|            auto m = in.template mark< M >();
   47|  4.49k|            using m_t = decltype( m );
   48|  6.86k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.36k, False: 2.13k]
  |  Branch (48:25): [True: 2.32k, False: 38]
  ------------------
   49|  4.49k|         }
   50|  4.49k|      }
_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.51k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.51k|         else {
   46|  3.51k|            auto m = in.template mark< M >();
   47|  3.51k|            using m_t = decltype( m );
   48|  6.97k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.46k, False: 52]
  |  Branch (48:25): [True: 3.44k, False: 22]
  ------------------
   49|  3.51k|         }
   50|  3.51k|      }
_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|   587k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   587k|         else {
   46|   587k|            auto m = in.template mark< M >();
   47|   587k|            using m_t = decltype( m );
   48|  1.17M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 584k, False: 2.78k]
  |  Branch (48:25): [True: 584k, False: 680]
  ------------------
   49|   587k|         }
   50|   587k|      }
_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|  37.8k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  37.8k|         else {
   46|  37.8k|            auto m = in.template mark< M >();
   47|  37.8k|            using m_t = decltype( m );
   48|  50.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.18k, False: 16]
  |  Branch (48:25): [True: 3.45k, False: 735]
  |  Branch (48:25): [True: 4.20k, False: 33.6k]
  ------------------
   49|  37.8k|         }
   50|  37.8k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.18k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.18k|         else {
   46|  4.18k|            auto m = in.template mark< M >();
   47|  4.18k|            using m_t = decltype( m );
   48|  32.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.87k, False: 0]
  |  Branch (48:25): [True: 2.72k, False: 141]
  |  Branch (48:25): [True: 2.87k, False: 80]
  |  Branch (48:25): [True: 2.95k, False: 0]
  |  Branch (48:25): [True: 2.95k, False: 1.23k]
  |  Branch (48:25): [True: 4.18k, False: 0]
  ------------------
   49|  4.18k|         }
   50|  4.18k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.18k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.18k|         else {
   46|  4.18k|            auto m = in.template mark< M >();
   47|  4.18k|            using m_t = decltype( m );
   48|  6.02k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.83k, False: 2.35k]
  |  Branch (48:25): [True: 1.79k, False: 41]
  ------------------
   49|  4.18k|         }
   50|  4.18k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.95k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.95k|         else {
   46|  2.95k|            auto m = in.template mark< M >();
   47|  2.95k|            using m_t = decltype( m );
   48|  5.84k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.89k, False: 60]
  |  Branch (48:25): [True: 2.87k, False: 20]
  ------------------
   49|  2.95k|         }
   50|  2.95k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  6.62k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.62k|         else {
   46|  6.62k|            auto m = in.template mark< M >();
   47|  6.62k|            using m_t = decltype( m );
   48|  11.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.45k, False: 2.16k]
  |  Branch (48:25): [True: 3.73k, False: 721]
  ------------------
   49|  6.62k|         }
   50|  6.62k|      }
_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|  34.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  34.0k|         else {
   46|  34.0k|            auto m = in.template mark< M >();
   47|  34.0k|            using m_t = decltype( m );
   48|  43.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.12k, False: 13]
  |  Branch (48:25): [True: 2.49k, False: 636]
  |  Branch (48:25): [True: 3.14k, False: 30.8k]
  ------------------
   49|  34.0k|         }
   50|  34.0k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.12k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.12k|         else {
   46|  3.12k|            auto m = in.template mark< M >();
   47|  3.12k|            using m_t = decltype( m );
   48|  23.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.95k, False: 0]
  |  Branch (48:25): [True: 1.83k, False: 119]
  |  Branch (48:25): [True: 1.95k, False: 81]
  |  Branch (48:25): [True: 2.03k, False: 0]
  |  Branch (48:25): [True: 2.03k, False: 1.09k]
  |  Branch (48:25): [True: 3.12k, False: 0]
  ------------------
   49|  3.12k|         }
   50|  3.12k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.12k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.12k|         else {
   46|  3.12k|            auto m = in.template mark< M >();
   47|  3.12k|            using m_t = decltype( m );
   48|  4.16k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.03k, False: 2.09k]
  |  Branch (48:25): [True: 990, False: 43]
  ------------------
   49|  3.12k|         }
   50|  3.12k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.03k|         else {
   46|  2.03k|            auto m = in.template mark< M >();
   47|  2.03k|            using m_t = decltype( m );
   48|  3.99k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.96k, False: 72]
  |  Branch (48:25): [True: 1.95k, False: 9]
  ------------------
   49|  2.03k|         }
   50|  2.03k|      }
_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.71k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.71k|         else {
   46|  4.71k|            auto m = in.template mark< M >();
   47|  4.71k|            using m_t = decltype( m );
   48|  8.07k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.35k, False: 1.36k]
  |  Branch (48:25): [True: 2.75k, False: 600]
  ------------------
   49|  4.71k|         }
   50|  4.71k|      }
_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|  31.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  31.2k|         else {
   46|  31.2k|            auto m = in.template mark< M >();
   47|  31.2k|            using m_t = decltype( m );
   48|  40.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.18k, False: 14]
  |  Branch (48:25): [True: 2.72k, False: 459]
  |  Branch (48:25): [True: 3.19k, False: 28.0k]
  ------------------
   49|  31.2k|         }
   50|  31.2k|      }
_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.18k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.18k|         else {
   46|  3.18k|            auto m = in.template mark< M >();
   47|  3.18k|            using m_t = decltype( m );
   48|  22.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.80k, False: 0]
  |  Branch (48:25): [True: 1.70k, False: 100]
  |  Branch (48:25): [True: 1.80k, False: 44]
  |  Branch (48:25): [True: 1.85k, False: 0]
  |  Branch (48:25): [True: 1.85k, False: 1.33k]
  |  Branch (48:25): [True: 3.18k, False: 0]
  ------------------
   49|  3.18k|         }
   50|  3.18k|      }
_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.18k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.18k|         else {
   46|  3.18k|            auto m = in.template mark< M >();
   47|  3.18k|            using m_t = decltype( m );
   48|  4.54k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.35k, False: 1.82k]
  |  Branch (48:25): [True: 1.32k, False: 31]
  ------------------
   49|  3.18k|         }
   50|  3.18k|      }
_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.85k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.85k|         else {
   46|  1.85k|            auto m = in.template mark< M >();
   47|  1.85k|            using m_t = decltype( m );
   48|  3.66k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.81k, False: 35]
  |  Branch (48:25): [True: 1.80k, False: 9]
  ------------------
   49|  1.85k|         }
   50|  1.85k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  3.71k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.71k|         else {
   46|  3.71k|            auto m = in.template mark< M >();
   47|  3.71k|            using m_t = decltype( m );
   48|  5.92k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.20k, False: 1.51k]
  |  Branch (48:25): [True: 1.89k, False: 307]
  ------------------
   49|  3.71k|         }
   50|  3.71k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12str_via_portENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  28.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  28.2k|         else {
   46|  28.2k|            auto m = in.template mark< M >();
   47|  28.2k|            using m_t = decltype( m );
   48|  40.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.94k, False: 17]
  |  Branch (48:25): [True: 3.26k, False: 685]
  |  Branch (48:25): [True: 3.96k, False: 24.2k]
  ------------------
   49|  28.2k|         }
   50|  28.2k|      }
_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.94k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.94k|         else {
   46|  3.94k|            auto m = in.template mark< M >();
   47|  3.94k|            using m_t = decltype( m );
   48|  30.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.63k, False: 0]
  |  Branch (48:25): [True: 2.48k, False: 144]
  |  Branch (48:25): [True: 2.63k, False: 82]
  |  Branch (48:25): [True: 2.71k, False: 0]
  |  Branch (48:25): [True: 2.71k, False: 1.23k]
  |  Branch (48:25): [True: 3.94k, False: 0]
  ------------------
   49|  3.94k|         }
   50|  3.94k|      }
_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.94k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.94k|         else {
   46|  3.94k|            auto m = in.template mark< M >();
   47|  3.94k|            using m_t = decltype( m );
   48|  5.49k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.54k, False: 2.39k]
  |  Branch (48:25): [True: 1.50k, False: 46]
  ------------------
   49|  3.94k|         }
   50|  3.94k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.71k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.71k|         else {
   46|  2.71k|            auto m = in.template mark< M >();
   47|  2.71k|            using m_t = decltype( m );
   48|  5.35k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.64k, False: 69]
  |  Branch (48:25): [True: 2.63k, False: 13]
  ------------------
   49|  2.71k|         }
   50|  2.71k|      }
_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|  5.24k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.24k|         else {
   46|  5.24k|            auto m = in.template mark< M >();
   47|  5.24k|            using m_t = decltype( m );
   48|  8.84k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.59k, False: 1.65k]
  |  Branch (48:25): [True: 2.60k, False: 993]
  ------------------
   49|  5.24k|         }
   50|  5.24k|      }
_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|  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|  35.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.51k, False: 6]
  |  Branch (48:25): [True: 3.08k, False: 430]
  |  Branch (48:25): [True: 3.52k, False: 21.1k]
  ------------------
   49|  24.6k|         }
   50|  24.6k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15interface_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.51k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.51k|         else {
   46|  3.51k|            auto m = in.template mark< M >();
   47|  3.51k|            using m_t = decltype( m );
   48|  27.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.42k, False: 0]
  |  Branch (48:25): [True: 2.24k, False: 176]
  |  Branch (48:25): [True: 2.42k, False: 57]
  |  Branch (48:25): [True: 2.47k, False: 0]
  |  Branch (48:25): [True: 2.47k, False: 1.03k]
  |  Branch (48:25): [True: 3.51k, False: 0]
  ------------------
   49|  3.51k|         }
   50|  3.51k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.51k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.51k|         else {
   46|  3.51k|            auto m = in.template mark< M >();
   47|  3.51k|            using m_t = decltype( m );
   48|  5.55k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.03k, False: 1.48k]
  |  Branch (48:25): [True: 1.99k, False: 39]
  ------------------
   49|  3.51k|         }
   50|  3.51k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15interface_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.47k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.47k|         else {
   46|  2.47k|            auto m = in.template mark< M >();
   47|  2.47k|            using m_t = decltype( m );
   48|  4.90k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.42k, False: 55]
  |  Branch (48:25): [True: 2.42k, False: 2]
  ------------------
   49|  2.47k|         }
   50|  2.47k|      }
_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|   162k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   162k|         else {
   46|   162k|            auto m = in.template mark< M >();
   47|   162k|            using m_t = decltype( m );
   48|   323k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 160k, False: 1.64k]
  |  Branch (48:25): [True: 159k, False: 780]
  ------------------
   49|   162k|         }
   50|   162k|      }
_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|   164k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   164k|         else {
   46|   164k|            auto m = in.template mark< M >();
   47|   164k|            using m_t = decltype( m );
   48|  1.30M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 163k, False: 25]
  |  Branch (48:25): [True: 163k, False: 13]
  |  Branch (48:25): [True: 163k, False: 30]
  |  Branch (48:25): [True: 163k, False: 37]
  |  Branch (48:25): [True: 163k, False: 1.15k]
  ------------------
   49|   164k|         }
   50|   164k|      }
_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|  21.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  21.5k|         else {
   46|  21.5k|            auto m = in.template mark< M >();
   47|  21.5k|            using m_t = decltype( m );
   48|  31.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.16k, False: 10]
  |  Branch (48:25): [True: 2.57k, False: 592]
  |  Branch (48:25): [True: 3.17k, False: 18.4k]
  ------------------
   49|  21.5k|         }
   50|  21.5k|      }
_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|  3.16k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.16k|         else {
   46|  3.16k|            auto m = in.template mark< M >();
   47|  3.16k|            using m_t = decltype( m );
   48|  27.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.52k, False: 0]
  |  Branch (48:25): [True: 2.40k, False: 121]
  |  Branch (48:25): [True: 2.52k, False: 84]
  |  Branch (48:25): [True: 2.60k, False: 0]
  |  Branch (48:25): [True: 2.60k, False: 555]
  |  Branch (48:25): [True: 3.16k, False: 0]
  ------------------
   49|  3.16k|         }
   50|  3.16k|      }
_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|  3.16k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.16k|         else {
   46|  3.16k|            auto m = in.template mark< M >();
   47|  3.16k|            using m_t = decltype( m );
   48|  4.43k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.27k, False: 1.88k]
  |  Branch (48:25): [True: 1.23k, False: 43]
  ------------------
   49|  3.16k|         }
   50|  3.16k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.60k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.60k|         else {
   46|  2.60k|            auto m = in.template mark< M >();
   47|  2.60k|            using m_t = decltype( m );
   48|  5.14k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.53k, False: 69]
  |  Branch (48:25): [True: 2.52k, False: 15]
  ------------------
   49|  2.60k|         }
   50|  2.60k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.56k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.56k|         else {
   46|  4.56k|            auto m = in.template mark< M >();
   47|  4.56k|            using m_t = decltype( m );
   48|  7.20k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.64k, False: 1.92k]
  |  Branch (48:25): [True: 2.02k, False: 618]
  ------------------
   49|  4.56k|         }
   50|  4.56k|      }
_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|  18.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  18.6k|         else {
   46|  18.6k|            auto m = in.template mark< M >();
   47|  18.6k|            using m_t = decltype( m );
   48|  39.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.76k, False: 22]
  |  Branch (48:25): [True: 3.71k, False: 3.04k]
  |  Branch (48:25): [True: 6.78k, False: 11.9k]
  ------------------
   49|  18.6k|         }
   50|  18.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|  6.76k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.76k|         else {
   46|  6.76k|            auto m = in.template mark< M >();
   47|  6.76k|            using m_t = decltype( m );
   48|  46.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.97k, False: 0]
  |  Branch (48:25): [True: 2.34k, False: 629]
  |  Branch (48:25): [True: 2.97k, False: 1.25k]
  |  Branch (48:25): [True: 4.22k, False: 0]
  |  Branch (48:25): [True: 4.22k, False: 2.53k]
  |  Branch (48:25): [True: 6.76k, False: 0]
  ------------------
   49|  6.76k|         }
   50|  6.76k|      }
_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|  6.76k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.76k|         else {
   46|  6.76k|            auto m = in.template mark< M >();
   47|  6.76k|            using m_t = decltype( m );
   48|  8.50k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.74k, False: 5.02k]
  |  Branch (48:25): [True: 1.67k, False: 70]
  ------------------
   49|  6.76k|         }
   50|  6.76k|      }
_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.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|  8.32k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.09k, False: 134]
  |  Branch (48:25): [True: 2.97k, False: 1.11k]
  ------------------
   49|  4.22k|         }
   50|  4.22k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   803k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   803k|         else {
   46|   803k|            auto m = in.template mark< M >();
   47|   803k|            using m_t = decltype( m );
   48|  1.60M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 801k, False: 2.55k]
  |  Branch (48:25): [True: 799k, False: 1.54k]
  ------------------
   49|   803k|         }
   50|   803k|      }
_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|   808k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   808k|         else {
   46|   808k|            auto m = in.template mark< M >();
   47|   808k|            using m_t = decltype( m );
   48|  3.23M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 807k, False: 1.19k]
  |  Branch (48:25): [True: 806k, False: 400]
  |  Branch (48:25): [True: 808k, False: 0]
  ------------------
   49|   808k|         }
   50|   808k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   808k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   808k|         else {
   46|   808k|            auto m = in.template mark< M >();
   47|   808k|            using m_t = decltype( m );
   48|  1.61M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 807k, False: 1.19k]
  |  Branch (48:25): [True: 807k, False: 0]
  ------------------
   49|   808k|         }
   50|   808k|      }
_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|  12.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  12.6k|         else {
   46|  12.6k|            auto m = in.template mark< M >();
   47|  12.6k|            using m_t = decltype( m );
   48|  24.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.03k, False: 23]
  |  Branch (48:25): [True: 3.34k, False: 689]
  |  Branch (48:25): [True: 4.05k, False: 8.60k]
  ------------------
   49|  12.6k|         }
   50|  12.6k|      }
_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.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.03k|         else {
   46|  4.03k|            auto m = in.template mark< M >();
   47|  4.03k|            using m_t = decltype( m );
   48|  27.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.14k, False: 0]
  |  Branch (48:25): [True: 2.00k, False: 136]
  |  Branch (48:25): [True: 2.14k, False: 79]
  |  Branch (48:25): [True: 2.22k, False: 0]
  |  Branch (48:25): [True: 2.22k, False: 1.81k]
  |  Branch (48:25): [True: 4.03k, False: 0]
  ------------------
   49|  4.03k|         }
   50|  4.03k|      }
_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.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.03k|         else {
   46|  4.03k|            auto m = in.template mark< M >();
   47|  4.03k|            using m_t = decltype( m );
   48|  5.30k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.26k, False: 2.76k]
  |  Branch (48:25): [True: 1.21k, False: 52]
  ------------------
   49|  4.03k|         }
   50|  4.03k|      }
_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.22k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.22k|         else {
   46|  2.22k|            auto m = in.template mark< M >();
   47|  2.22k|            using m_t = decltype( m );
   48|  4.37k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.15k, False: 67]
  |  Branch (48:25): [True: 2.14k, False: 12]
  ------------------
   49|  2.22k|         }
   50|  2.22k|      }
_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.85k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.85k|         else {
   46|  4.85k|            auto m = in.template mark< M >();
   47|  4.85k|            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.22k, False: 1.62k]
  |  Branch (48:25): [True: 2.70k, False: 524]
  ------------------
   49|  4.85k|         }
   50|  4.85k|      }
_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|  31.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  31.6k|         else {
   46|  31.6k|            auto m = in.template mark< M >();
   47|  31.6k|            using m_t = decltype( m );
   48|  37.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.56k, False: 26.0k]
  |  Branch (48:25): [True: 3.03k, False: 2.52k]
  ------------------
   49|  31.6k|         }
   50|  31.6k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  42.5k|      {
   58|  42.5k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  42.5k|      }
_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|  42.5k|      {
   45|  85.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 29, False: 42.4k]
  |  Branch (45:19): [True: 42.3k, False: 108]
  ------------------
   46|  42.5k|      }
_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|  42.4k|      {
   58|  42.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  42.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  42.4k|      {
   45|  54.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 851, False: 150]
  |  Branch (45:19): [True: 42, False: 108]
  |  Branch (45:19): [True: 9, False: 1.00k]
  |  Branch (45:19): [True: 2.80k, False: 1.01k]
  |  Branch (45:19): [True: 38.6k, False: 3.81k]
  ------------------
   46|  42.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  45.9k|      {
   58|  45.9k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  45.9k|      }
_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|  45.9k|      {
   45|  87.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 4.00k, False: 41.9k]
  |  Branch (45:19): [True: 3.17k, False: 38.7k]
  ------------------
   46|  45.9k|      }
_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|  45.2k|      {
   58|  45.2k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  45.2k|      }
_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|  45.2k|      {
   45|   534k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 6.03k, False: 12.6k]
  |  Branch (45:19): [True: 3.68k, False: 8.98k]
  |  Branch (45:19): [True: 2.87k, False: 18.6k]
  |  Branch (45:19): [True: 3.09k, False: 21.5k]
  |  Branch (45:19): [True: 3.59k, False: 24.6k]
  |  Branch (45:19): [True: 2.95k, False: 28.2k]
  |  Branch (45:19): [True: 2.81k, False: 31.2k]
  |  Branch (45:19): [True: 3.83k, False: 34.0k]
  |  Branch (45:19): [True: 4.16k, False: 37.8k]
  |  Branch (45:19): [True: 3.22k, False: 42.0k]
  ------------------
   46|  45.2k|      }
_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.67k|      {
   58|  3.67k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.67k|      }
_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.67k|      {
   45|  5.17k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.17k, False: 1.50k]
  |  Branch (45:19): [True: 1.04k, False: 453]
  ------------------
   46|  3.67k|      }
_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.67k|      {
   58|  3.67k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.67k|      }
_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.67k|      {
   45|  30.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 602, False: 2.21k]
  |  Branch (45:19): [True: 195, False: 2.02k]
  |  Branch (45:19): [True: 222, False: 2.81k]
  |  Branch (45:19): [True: 194, False: 3.04k]
  |  Branch (45:19): [True: 212, False: 3.23k]
  |  Branch (45:19): [True: 226, False: 3.44k]
  ------------------
   46|  3.67k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.58M|      {
   58|  1.58M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.58M|      }
_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.58M|      {
   45|  3.17M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.68k, False: 1.58M]
  |  Branch (45:19): [True: 1.58M, False: 1.64k]
  ------------------
   46|  1.58M|      }
_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.49k|      {
   58|  4.49k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.49k|      }
_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.49k|      {
   45|  5.65k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.33k, False: 1.16k]
  |  Branch (45:19): [True: 820, False: 340]
  ------------------
   46|  4.49k|      }
_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.49k|      {
   58|  4.49k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.49k|      }
_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.49k|      {
   45|  33.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 352, False: 2.34k]
  |  Branch (45:19): [True: 211, False: 2.13k]
  |  Branch (45:19): [True: 194, False: 2.69k]
  |  Branch (45:19): [True: 809, False: 2.88k]
  |  Branch (45:19): [True: 419, False: 3.69k]
  |  Branch (45:19): [True: 379, False: 4.11k]
  ------------------
   46|  4.49k|      }
_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|  17.4M|      {
   58|  17.4M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  17.4M|      }
_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|  17.4M|      {
   45|  34.6M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 245k, False: 17.1M]
  |  Branch (45:19): [True: 17.1M, False: 219]
  ------------------
   46|  17.4M|      }
_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|   245k|      {
   58|   245k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   245k|      }
_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|   245k|      {
   45|   743k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 98.2k, False: 5.42k]
  |  Branch (45:19): [True: 5.36k, False: 63]
  |  Branch (45:19): [True: 39.2k, False: 103k]
  |  Branch (45:19): [True: 102k, False: 142k]
  ------------------
   46|   245k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.18k|      {
   58|  4.18k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.18k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.18k|      {
   45|  5.61k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.76k, False: 1.42k]
  |  Branch (45:19): [True: 1.06k, False: 359]
  ------------------
   46|  4.18k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.18k|      {
   58|  4.18k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.18k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.18k|      {
   45|  33.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 260, False: 2.57k]
  |  Branch (45:19): [True: 224, False: 2.35k]
  |  Branch (45:19): [True: 197, False: 2.83k]
  |  Branch (45:19): [True: 381, False: 3.03k]
  |  Branch (45:19): [True: 547, False: 3.41k]
  |  Branch (45:19): [True: 225, False: 3.96k]
  ------------------
   46|  4.18k|      }
_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|  12.0M|      {
   58|  12.0M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  12.0M|      }
_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|  12.0M|      {
   45|  23.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 176k, False: 11.9M]
  |  Branch (45:19): [True: 11.9M, False: 202]
  ------------------
   46|  12.0M|      }
_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|   176k|      {
   58|   176k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   176k|      }
_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|   176k|      {
   45|   546k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 58.6k, False: 1.22k]
  |  Branch (45:19): [True: 1.16k, False: 57]
  |  Branch (45:19): [True: 64.7k, False: 59.8k]
  |  Branch (45:19): [True: 52.0k, False: 124k]
  ------------------
   46|   176k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.12k|      {
   58|  3.12k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.12k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.12k|      {
   45|  4.38k|         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.26k]
  |  Branch (45:19): [True: 943, False: 318]
  ------------------
   46|  3.12k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.12k|      {
   58|  3.12k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.12k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.12k|      {
   45|  26.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 251, False: 2.16k]
  |  Branch (45:19): [True: 71, False: 2.09k]
  |  Branch (45:19): [True: 194, False: 2.41k]
  |  Branch (45:19): [True: 67, False: 2.61k]
  |  Branch (45:19): [True: 237, False: 2.67k]
  |  Branch (45:19): [True: 213, False: 2.91k]
  ------------------
   46|  3.12k|      }
_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|  9.96M|      {
   58|  9.96M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.96M|      }
_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|  9.96M|      {
   45|  19.7M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 131k, False: 9.83M]
  |  Branch (45:19): [True: 9.83M, False: 177]
  ------------------
   46|  9.96M|      }
_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|   131k|      {
   58|   131k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   131k|      }
_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|   131k|      {
   45|   423k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 58.1k, False: 831]
  |  Branch (45:19): [True: 779, False: 52]
  |  Branch (45:19): [True: 27.4k, False: 59.0k]
  |  Branch (45:19): [True: 45.0k, False: 86.4k]
  ------------------
   46|   131k|      }
_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.18k|      {
   58|  3.18k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.18k|      }
_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.18k|      {
   45|  4.64k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.72k, False: 1.45k]
  |  Branch (45:19): [True: 1.21k, False: 239]
  ------------------
   46|  3.18k|      }
_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.18k|      {
   58|  3.18k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.18k|      }
_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.18k|      {
   45|  26.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 209, False: 2.06k]
  |  Branch (45:19): [True: 234, False: 1.82k]
  |  Branch (45:19): [True: 280, False: 2.27k]
  |  Branch (45:19): [True: 194, False: 2.55k]
  |  Branch (45:19): [True: 206, False: 2.74k]
  |  Branch (45:19): [True: 234, False: 2.95k]
  ------------------
   46|  3.18k|      }
_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.66M|      {
   58|  2.66M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.66M|      }
_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.66M|      {
   45|  5.33M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 8.36k, False: 2.66M]
  |  Branch (45:19): [True: 2.66M, False: 159]
  ------------------
   46|  2.66M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  8.36k|      {
   58|  8.36k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  8.36k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  8.36k|      {
   45|  26.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.55k, False: 270]
  |  Branch (45:19): [True: 242, False: 28]
  |  Branch (45:19): [True: 1.51k, False: 3.82k]
  |  Branch (45:19): [True: 3.01k, False: 5.34k]
  ------------------
   46|  8.36k|      }
_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.94k|      {
   58|  3.94k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.94k|      }
_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.94k|      {
   45|  5.36k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.52k, False: 1.42k]
  |  Branch (45:19): [True: 1.07k, False: 354]
  ------------------
   46|  3.94k|      }
_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.94k|      {
   58|  3.94k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.94k|      }
_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.94k|      {
   45|  33.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 269, False: 2.67k]
  |  Branch (45:19): [True: 279, False: 2.39k]
  |  Branch (45:19): [True: 334, False: 2.94k]
  |  Branch (45:19): [True: 195, False: 3.28k]
  |  Branch (45:19): [True: 250, False: 3.47k]
  |  Branch (45:19): [True: 220, False: 3.72k]
  ------------------
   46|  3.94k|      }
_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|  9.02M|      {
   58|  9.02M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.02M|      }
_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|  9.02M|      {
   45|  17.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 97.4k, False: 8.92M]
  |  Branch (45:19): [True: 8.92M, False: 192]
  ------------------
   46|  9.02M|      }
_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|  97.4k|      {
   58|  97.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  97.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  97.4k|      {
   45|   315k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 38.8k, False: 642]
  |  Branch (45:19): [True: 581, False: 61]
  |  Branch (45:19): [True: 29.7k, False: 39.4k]
  |  Branch (45:19): [True: 28.2k, False: 69.2k]
  ------------------
   46|  97.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|  3.51k|      {
   58|  3.51k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.51k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.51k|      {
   45|  4.78k|         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.26k]
  |  Branch (45:19): [True: 843, False: 426]
  ------------------
   46|  3.51k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.51k|      {
   58|  3.51k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.51k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.51k|      {
   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: 494, False: 1.92k]
  |  Branch (45:19): [True: 437, False: 1.48k]
  |  Branch (45:19): [True: 303, False: 2.41k]
  |  Branch (45:19): [True: 302, False: 2.71k]
  |  Branch (45:19): [True: 228, False: 3.01k]
  |  Branch (45:19): [True: 270, False: 3.24k]
  ------------------
   46|  3.51k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   326k|      {
   58|   326k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   326k|      }
_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|   326k|      {
   45|   479k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 174k, False: 152k]
  |  Branch (45:19): [True: 152k, False: 43]
  ------------------
   46|   326k|      }
_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|  3.16k|      {
   58|  3.16k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.16k|      }
_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|  3.16k|      {
   45|  3.87k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.44k, False: 715]
  |  Branch (45:19): [True: 427, False: 288]
  ------------------
   46|  3.16k|      }
_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|  3.16k|      {
   58|  3.16k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.16k|      }
_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|  3.16k|      {
   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: 261, False: 2.08k]
  |  Branch (45:19): [True: 195, False: 1.88k]
  |  Branch (45:19): [True: 194, False: 2.34k]
  |  Branch (45:19): [True: 325, False: 2.53k]
  |  Branch (45:19): [True: 95, False: 2.86k]
  |  Branch (45:19): [True: 204, False: 2.95k]
  ------------------
   46|  3.16k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.46M|      {
   58|  7.46M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.46M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.46M|      {
   45|  14.8M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 75.4k, False: 7.38M]
  |  Branch (45:19): [True: 7.38M, False: 177]
  ------------------
   46|  7.46M|      }
_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|  75.4k|      {
   58|  75.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  75.4k|      }
_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|  75.4k|      {
   45|   252k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 31.2k, False: 598]
  |  Branch (45:19): [True: 554, False: 44]
  |  Branch (45:19): [True: 24.6k, False: 31.8k]
  |  Branch (45:19): [True: 19.0k, False: 56.4k]
  ------------------
   46|  75.4k|      }
_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|  6.76k|      {
   58|  6.76k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.76k|      {
   45|  9.96k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.56k, False: 3.20k]
  |  Branch (45:19): [True: 2.46k, False: 739]
  ------------------
   46|  6.76k|      }
_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|  6.76k|      {
   58|  6.76k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.76k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.76k|      {
   45|  60.1k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 265, False: 5.27k]
  |  Branch (45:19): [True: 248, False: 5.02k]
  |  Branch (45:19): [True: 345, False: 5.53k]
  |  Branch (45:19): [True: 198, False: 5.88k]
  |  Branch (45:19): [True: 483, False: 6.07k]
  |  Branch (45:19): [True: 201, False: 6.56k]
  ------------------
   46|  6.76k|      }
_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|  53.2M|      {
   58|  53.2M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  53.2M|      }
_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|  53.2M|      {
   45|   106M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 163k, False: 53.1M]
  |  Branch (45:19): [True: 53.1M, False: 289]
  ------------------
   46|  53.2M|      }
_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|   163k|      {
   58|   163k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   163k|      }
_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|   163k|      {
   45|   557k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 84.7k, False: 422]
  |  Branch (45:19): [True: 356, False: 66]
  |  Branch (45:19): [True: 26.3k, False: 85.2k]
  |  Branch (45:19): [True: 51.5k, False: 111k]
  ------------------
   46|   163k|      }
_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.03k|      {
   58|  4.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.03k|      }
_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.03k|      {
   45|  6.03k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.03k, False: 2.00k]
  |  Branch (45:19): [True: 1.64k, False: 356]
  ------------------
   46|  4.03k|      }
_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.03k|      {
   58|  4.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.03k|      }
_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.03k|      {
   45|  35.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 287, False: 3.01k]
  |  Branch (45:19): [True: 246, False: 2.76k]
  |  Branch (45:19): [True: 194, False: 3.30k]
  |  Branch (45:19): [True: 209, False: 3.49k]
  |  Branch (45:19): [True: 116, False: 3.70k]
  |  Branch (45:19): [True: 217, False: 3.81k]
  ------------------
   46|  4.03k|      }
_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|  8.59M|      {
   58|  8.59M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  8.59M|      }
_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|  8.59M|      {
   45|  17.0M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 163k, False: 8.43M]
  |  Branch (45:19): [True: 8.43M, False: 187]
  ------------------
   46|  8.59M|      }
_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|   163k|      {
   58|   163k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   163k|      }
_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|   163k|      {
   45|   466k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 39.2k, False: 1.03k]
  |  Branch (45:19): [True: 975, False: 60]
  |  Branch (45:19): [True: 70.1k, False: 40.3k]
  |  Branch (45:19): [True: 53.1k, False: 110k]
  ------------------
   46|   163k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|   160k|      {
   41|   182k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 21.5k, False: 160k]
  ------------------
   42|  21.5k|         }
   43|   160k|         return true;
   44|   160k|      }
_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|  13.2k|      {
   41|   834k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 821k, False: 13.2k]
  ------------------
   42|   821k|         }
   43|  13.2k|         return true;
   44|  13.2k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.73k|      {
   41|  8.47k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.73k, False: 4.73k]
  ------------------
   42|  3.73k|         }
   43|  4.73k|         return true;
   44|  4.73k|      }
_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.33k|      {
   41|   791k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 789k, False: 2.33k]
  ------------------
   42|   789k|         }
   43|  2.33k|         return true;
   44|  2.33k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.95k|      {
   41|  9.17k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.22k, False: 6.95k]
  ------------------
   42|  2.22k|         }
   43|  6.95k|         return true;
   44|  6.95k|      }
_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.46k|      {
   41|   587k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 584k, False: 3.46k]
  ------------------
   42|   584k|         }
   43|  3.46k|         return true;
   44|  3.46k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.82k|      {
   41|  9.07k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.25k, False: 5.82k]
  ------------------
   42|  3.25k|         }
   43|  5.82k|         return true;
   44|  5.82k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.89k|      {
   41|  6.62k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.73k, False: 2.89k]
  ------------------
   42|  3.73k|         }
   43|  2.89k|         return true;
   44|  2.89k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.98k|      {
   41|  6.40k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.42k, False: 3.98k]
  ------------------
   42|  2.42k|         }
   43|  3.98k|         return true;
   44|  3.98k|      }
_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.96k|      {
   41|  4.71k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.75k, False: 1.96k]
  ------------------
   42|  2.75k|         }
   43|  1.96k|         return true;
   44|  1.96k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.66k|      {
   41|  5.47k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.81k, False: 3.66k]
  ------------------
   42|  1.81k|         }
   43|  3.66k|         return true;
   44|  3.66k|      }
_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.81k|      {
   41|  3.71k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.89k, False: 1.81k]
  ------------------
   42|  1.89k|         }
   43|  1.81k|         return true;
   44|  1.81k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.34k|      {
   41|  8.82k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.47k, False: 5.34k]
  ------------------
   42|  3.47k|         }
   43|  5.34k|         return true;
   44|  5.34k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.64k|      {
   41|  5.24k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.60k, False: 2.64k]
  ------------------
   42|  2.60k|         }
   43|  2.64k|         return true;
   44|  2.64k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.89k|      {
   41|  8.83k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.93k, False: 4.89k]
  ------------------
   42|  3.93k|         }
   43|  4.89k|         return true;
   44|  4.89k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.42k|      {
   41|   162k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 159k, False: 2.42k]
  ------------------
   42|   159k|         }
   43|  2.42k|         return true;
   44|  2.42k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.13k|      {
   41|  8.44k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.31k, False: 5.13k]
  ------------------
   42|  3.31k|         }
   43|  5.13k|         return true;
   44|  5.13k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.53k|      {
   41|  4.56k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.02k, False: 2.53k]
  ------------------
   42|  2.02k|         }
   43|  2.53k|         return true;
   44|  2.53k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  7.20k|      {
   41|  10.6k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.47k, False: 7.20k]
  ------------------
   42|  3.47k|         }
   43|  7.20k|         return true;
   44|  7.20k|      }
_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.09k|      {
   41|   803k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 799k, False: 4.09k]
  ------------------
   42|   799k|         }
   43|  4.09k|         return true;
   44|  4.09k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   807k|      {
   41|  26.6M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 25.8M, False: 807k]
  ------------------
   42|  25.8M|         }
   43|   807k|         return true;
   44|   807k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.36k|      {
   41|  6.05k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.69k, False: 4.36k]
  ------------------
   42|  1.69k|         }
   43|  4.36k|         return true;
   44|  4.36k|      }
_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.15k|      {
   41|  4.85k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.70k, False: 2.15k]
  ------------------
   42|  2.70k|         }
   43|  2.15k|         return true;
   44|  2.15k|      }
_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|  28.6k|      {
   41|  31.6k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.03k, False: 28.6k]
  ------------------
   42|  3.03k|         }
   43|  28.6k|         return true;
   44|  28.6k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   455k|   {
   24|   455k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   455k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  42.4k|      {
   52|  42.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 42.4k, False: 47]
  ------------------
   53|  42.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 38.6k, False: 3.76k]
  ------------------
   54|  38.6k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  38.6k|               return true;
   56|  38.6k|            }
   57|  42.4k|         }
   58|  3.81k|         return false;
   59|  42.4k|      }
_ZN3tao5pegtl8internal6stringIJLc98ELc108ELc111ELc99ELc107EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  3.81k|      {
   52|  3.81k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 3.76k, False: 47]
  ------------------
   53|  3.76k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.80k, False: 963]
  ------------------
   54|  2.80k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.80k|               return true;
   56|  2.80k|            }
   57|  3.76k|         }
   58|  1.01k|         return false;
   59|  3.81k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.01k|      {
   52|  1.01k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 926, False: 84]
  ------------------
   53|    926|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 9, False: 917]
  ------------------
   54|      9|               bump_help< string >( in, sizeof...( Cs ) );
   55|      9|               return true;
   56|      9|            }
   57|    926|         }
   58|  1.00k|         return false;
   59|  1.01k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.00k|      {
   52|  1.00k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 954, False: 47]
  ------------------
   53|    954|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 851, False: 103]
  ------------------
   54|    851|               bump_help< string >( in, sizeof...( Cs ) );
   55|    851|               return true;
   56|    851|            }
   57|    954|         }
   58|    150|         return false;
   59|  1.00k|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    150|      {
   52|    150|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 67, False: 83]
  ------------------
   53|     67|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 42, False: 25]
  ------------------
   54|     42|               bump_help< string >( in, sizeof...( Cs ) );
   55|     42|               return true;
   56|     42|            }
   57|     67|         }
   58|    108|         return false;
   59|    150|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  45.2k|      {
   52|  45.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 43.5k, False: 1.73k]
  ------------------
   53|  43.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.69k, False: 39.8k]
  ------------------
   54|  3.69k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.69k|               return true;
   56|  3.69k|            }
   57|  43.5k|         }
   58|  41.5k|         return false;
   59|  45.2k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  40.0k|      {
   52|  40.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 32.9k, False: 7.13k]
  ------------------
   53|  32.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.38k, False: 30.5k]
  ------------------
   54|  2.38k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.38k|               return true;
   56|  2.38k|            }
   57|  32.9k|         }
   58|  37.7k|         return false;
   59|  40.0k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  37.7k|      {
   52|  37.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 30.5k, False: 7.13k]
  ------------------
   53|  30.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.79k, False: 27.7k]
  ------------------
   54|  2.79k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.79k|               return true;
   56|  2.79k|            }
   57|  30.5k|         }
   58|  34.9k|         return false;
   59|  37.7k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  34.9k|      {
   52|  34.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 26.3k, False: 8.52k]
  ------------------
   53|  26.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.87k, False: 23.5k]
  ------------------
   54|  2.87k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.87k|               return true;
   56|  2.87k|            }
   57|  26.3k|         }
   58|  32.0k|         return false;
   59|  34.9k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  32.0k|      {
   52|  32.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 17.0k, False: 14.9k]
  ------------------
   53|  17.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.45k, False: 14.6k]
  ------------------
   54|  2.45k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.45k|               return true;
   56|  2.45k|            }
   57|  17.0k|         }
   58|  29.5k|         return false;
   59|  32.0k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  29.5k|      {
   52|  29.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 22.4k, False: 7.13k]
  ------------------
   53|  22.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.25k, False: 19.1k]
  ------------------
   54|  3.25k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.25k|               return true;
   56|  3.25k|            }
   57|  22.4k|         }
   58|  26.3k|         return false;
   59|  29.5k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  26.3k|      {
   52|  26.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.3k, False: 9.99k]
  ------------------
   53|  16.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.34k, False: 13.9k]
  ------------------
   54|  2.34k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.34k|               return true;
   56|  2.34k|            }
   57|  16.3k|         }
   58|  23.9k|         return false;
   59|  26.3k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  42.0k|      {
   52|  42.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 40.0k, False: 1.95k]
  ------------------
   53|  40.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.51k, False: 35.5k]
  ------------------
   54|  4.51k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.51k|               return true;
   56|  4.51k|            }
   57|  40.0k|         }
   58|  37.5k|         return false;
   59|  42.0k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  37.8k|      {
   52|  37.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 35.8k, False: 1.95k]
  ------------------
   53|  35.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.20k, False: 31.6k]
  ------------------
   54|  4.20k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.20k|               return true;
   56|  4.20k|            }
   57|  35.8k|         }
   58|  33.6k|         return false;
   59|  37.8k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  34.0k|      {
   52|  34.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.1k, False: 5.84k]
  ------------------
   53|  28.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.14k, False: 25.0k]
  ------------------
   54|  3.14k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.14k|               return true;
   56|  3.14k|            }
   57|  28.1k|         }
   58|  30.8k|         return false;
   59|  34.0k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  31.2k|      {
   52|  31.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.8k, False: 2.34k]
  ------------------
   53|  28.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.20k, False: 25.6k]
  ------------------
   54|  3.20k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.20k|               return true;
   56|  3.20k|            }
   57|  28.8k|         }
   58|  28.0k|         return false;
   59|  31.2k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  28.2k|      {
   52|  28.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 24.9k, False: 3.35k]
  ------------------
   53|  24.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.96k, False: 20.9k]
  ------------------
   54|  3.96k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.96k|               return true;
   56|  3.96k|            }
   57|  24.9k|         }
   58|  24.2k|         return false;
   59|  28.2k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_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: 18.4k, False: 6.17k]
  ------------------
   53|  18.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.52k, False: 14.9k]
  ------------------
   54|  3.52k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.52k|               return true;
   56|  3.52k|            }
   57|  18.4k|         }
   58|  21.1k|         return false;
   59|  24.6k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  21.5k|      {
   52|  21.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 14.0k, False: 7.51k]
  ------------------
   53|  14.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.17k, False: 10.8k]
  ------------------
   54|  3.17k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.17k|               return true;
   56|  3.17k|            }
   57|  14.0k|         }
   58|  18.3k|         return false;
   59|  21.5k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  18.6k|      {
   52|  18.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.9k, False: 1.73k]
  ------------------
   53|  16.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 6.79k, False: 10.1k]
  ------------------
   54|  6.79k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  6.79k|               return true;
   56|  6.79k|            }
   57|  16.9k|         }
   58|  11.9k|         return false;
   59|  18.6k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  12.6k|      {
   52|  12.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 10.5k, False: 2.08k]
  ------------------
   53|  10.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.05k, False: 6.52k]
  ------------------
   54|  4.05k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.05k|               return true;
   56|  4.05k|            }
   57|  10.5k|         }
   58|  8.60k|         return false;
   59|  12.6k|      }

_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   588k|      {
   71|   588k|         auto m = in.template mark< M >();
   72|   588k|         using m_t = decltype( m );
   73|       |
   74|  18.0M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 17.4M, False: 588k]
  ------------------
   75|  17.4M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 219, False: 17.4M]
  ------------------
   76|    219|               return false;
   77|    219|            }
   78|  17.4M|         }
   79|   588k|         return m( true );
   80|   588k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  7.72k|      {
   71|  7.72k|         auto m = in.template mark< M >();
   72|  7.72k|         using m_t = decltype( m );
   73|       |
   74|  12.0M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 12.0M, False: 7.52k]
  ------------------
   75|  12.0M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 202, False: 12.0M]
  ------------------
   76|    202|               return false;
   77|    202|            }
   78|  12.0M|         }
   79|  7.52k|         return m( true );
   80|  7.72k|      }
_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.69k|      {
   71|  5.69k|         auto m = in.template mark< M >();
   72|  5.69k|         using m_t = decltype( m );
   73|       |
   74|  9.97M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.96M, False: 5.51k]
  ------------------
   75|  9.96M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 177, False: 9.96M]
  ------------------
   76|    177|               return false;
   77|    177|            }
   78|  9.96M|         }
   79|  5.51k|         return m( true );
   80|  5.69k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.95k|      {
   71|  4.95k|         auto m = in.template mark< M >();
   72|  4.95k|         using m_t = decltype( m );
   73|       |
   74|  2.67M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 2.66M, False: 4.79k]
  ------------------
   75|  2.66M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 159, False: 2.66M]
  ------------------
   76|    159|               return false;
   77|    159|            }
   78|  2.66M|         }
   79|  4.79k|         return m( true );
   80|  4.95k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.35k|      {
   71|  6.35k|         auto m = in.template mark< M >();
   72|  6.35k|         using m_t = decltype( m );
   73|       |
   74|  9.02M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.02M, False: 6.15k]
  ------------------
   75|  9.02M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 192, False: 9.02M]
  ------------------
   76|    192|               return false;
   77|    192|            }
   78|  9.02M|         }
   79|  6.15k|         return m( true );
   80|  6.35k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.03k|      {
   71|  5.03k|         auto m = in.template mark< M >();
   72|  5.03k|         using m_t = decltype( m );
   73|       |
   74|  7.46M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.46M, False: 4.85k]
  ------------------
   75|  7.46M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 177, False: 7.46M]
  ------------------
   76|    177|               return false;
   77|    177|            }
   78|  7.46M|         }
   79|  4.85k|         return m( true );
   80|  5.03k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  41.0k|      {
   71|  41.0k|         auto m = in.template mark< M >();
   72|  41.0k|         using m_t = decltype( m );
   73|       |
   74|  53.3M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 53.2M, False: 40.7k]
  ------------------
   75|  53.2M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 289, False: 53.2M]
  ------------------
   76|    289|               return false;
   77|    289|            }
   78|  53.2M|         }
   79|  40.7k|         return m( true );
   80|  41.0k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.53k|      {
   71|  6.53k|         auto m = in.template mark< M >();
   72|  6.53k|         using m_t = decltype( m );
   73|       |
   74|  8.60M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 8.59M, False: 6.34k]
  ------------------
   75|  8.59M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 187, False: 8.59M]
  ------------------
   76|    187|               return false;
   77|    187|            }
   78|  8.59M|         }
   79|  6.34k|         return m( true );
   80|  6.53k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  42.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.5k|      else {
  108|  42.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.3k, False: 9.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  42.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.3k, False: 9.19k]
  ------------------
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|  9.19k|         else {
  160|  9.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.19k|         }
  162|  42.5k|         (void)m( result );
  163|  42.5k|         return result;
  164|  42.5k|      }
  165|  42.5k|   }
_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|  42.5k|      {
   73|  42.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.5k|         else {
   84|  42.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  42.5k|      {
   44|  42.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.5k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   160k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   160k|      else {
  108|   160k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   160k|         using iterator_t = typename ParseInput::iterator_t;
  111|   160k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   160k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   160k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   160k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   160k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   160k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   160k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   160k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   160k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   160k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   160k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   160k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   160k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   160k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   160k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   160k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   160k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   160k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 160k, 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|   160k|            else if constexpr( has_apply0_bool ) {
  153|   160k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   160k|            }
  155|   160k|         }
  156|   160k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 160k, False: 0]
  ------------------
  157|   160k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   160k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   160k|         (void)m( result );
  163|   160k|         return result;
  164|   160k|      }
  165|   160k|   }
_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|   160k|      {
   73|   160k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   160k|         else {
   84|   160k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   160k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   160k|      }
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|   160k|      {
   44|   160k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   160k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   279k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   279k|      else {
  108|   279k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   279k|         using iterator_t = typename ParseInput::iterator_t;
  111|   279k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   279k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   279k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   279k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   279k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   279k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   279k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   279k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   279k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   279k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   279k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   279k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   279k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   279k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   279k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   279k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   279k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   279k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.9k, False: 248k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  30.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.9k|            }
  155|  30.9k|         }
  156|   279k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.9k, False: 248k]
  ------------------
  157|  30.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.9k|         }
  159|   248k|         else {
  160|   248k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   248k|         }
  162|   279k|         (void)m( result );
  163|   279k|         return result;
  164|   279k|      }
  165|   279k|   }
_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|   279k|      {
   73|   279k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   279k|         else {
   84|   279k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   279k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   279k|      }
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|   279k|      {
   59|   279k|         return Rule::match( in );
   60|   279k|      }
_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|  42.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.5k|      else {
  108|  42.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 4.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  37.9k|            else if constexpr( has_apply0_bool ) {
  153|  37.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.9k|            }
  155|  37.9k|         }
  156|  42.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 4.61k]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|  4.61k|         else {
  160|  4.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.61k|         }
  162|  42.5k|         (void)m( result );
  163|  42.5k|         return result;
  164|  42.5k|      }
  165|  42.5k|   }
_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|  42.5k|      {
   73|  42.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.5k|         else {
   84|  42.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  42.5k|      {
   44|  42.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.5k|      }
_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|  42.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.5k|      else {
  108|  42.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.7k, False: 4.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|  37.7k|            else if constexpr( has_apply0_bool ) {
  153|  37.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.7k|            }
  155|  37.7k|         }
  156|  42.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.7k, False: 4.72k]
  ------------------
  157|  37.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.7k|         }
  159|  4.72k|         else {
  160|  4.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.72k|         }
  162|  42.5k|         (void)m( result );
  163|  42.5k|         return result;
  164|  42.5k|      }
  165|  42.5k|   }
_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|  42.5k|      {
   73|  42.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.5k|         else {
   84|  42.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  42.5k|      {
   44|  42.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  80.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  80.2k|      else {
  108|  80.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  80.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  80.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|  80.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|  80.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|  80.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): [True: 0, Folded]
  ------------------
  116|  80.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|  80.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [True: 80.2k, Folded]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  80.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  80.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  80.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  80.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|  80.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  80.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  80.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|  80.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  80.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  80.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  80.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  80.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2k, False: 67.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|  13.2k|            else if constexpr( has_apply0_void ) {
  150|  13.2k|               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|  13.2k|         }
  156|  80.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2k, False: 67.0k]
  ------------------
  157|  13.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2k|         }
  159|  67.0k|         else {
  160|  67.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.0k|         }
  162|  80.2k|         (void)m( result );
  163|  80.2k|         return result;
  164|  80.2k|      }
  165|  80.2k|   }
_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|  80.2k|      {
   73|  80.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|  80.2k|         else {
   84|  80.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  80.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  80.2k|      }
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|  80.2k|      {
   44|  80.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  80.2k|      }
_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|  80.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  80.2k|      else {
  108|  80.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  80.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  80.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|  80.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|  80.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|  80.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|  80.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|  80.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|  80.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  80.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  80.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  80.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|  80.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  80.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  80.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|  80.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  80.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  80.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  80.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  80.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2k, False: 67.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|  13.2k|            else if constexpr( has_apply0_bool ) {
  153|  13.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.2k|            }
  155|  13.2k|         }
  156|  80.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2k, False: 67.0k]
  ------------------
  157|  13.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2k|         }
  159|  67.0k|         else {
  160|  67.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.0k|         }
  162|  80.2k|         (void)m( result );
  163|  80.2k|         return result;
  164|  80.2k|      }
  165|  80.2k|   }
_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|  80.2k|      {
   73|  80.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|  80.2k|         else {
   84|  80.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  80.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  80.2k|      }
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|  80.2k|      {
   44|  80.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  80.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  80.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  80.2k|      else {
  108|  80.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  80.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  80.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|  80.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|  80.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|  80.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|  80.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|  80.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|  80.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  80.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  80.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  80.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|  80.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  80.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  80.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|  80.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  80.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  80.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  80.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  80.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2k, False: 67.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|  13.2k|            else if constexpr( has_apply0_bool ) {
  153|  13.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.2k|            }
  155|  13.2k|         }
  156|  80.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2k, False: 67.0k]
  ------------------
  157|  13.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2k|         }
  159|  67.0k|         else {
  160|  67.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.0k|         }
  162|  80.2k|         (void)m( result );
  163|  80.2k|         return result;
  164|  80.2k|      }
  165|  80.2k|   }
_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|  80.2k|      {
   73|  80.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|  80.2k|         else {
   84|  80.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  80.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  80.2k|      }
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|  80.2k|      {
   59|  80.2k|         return Rule::match( in );
   60|  80.2k|      }
_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|  13.2k|   {
  104|  13.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  13.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|  13.2k|   }
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|  13.2k|      {
   44|  13.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.2k|      }
_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|  13.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2k|      else {
  108|  13.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.2k|            else if constexpr( has_apply0_bool ) {
  153|  13.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.2k|            }
  155|  13.2k|         }
  156|  13.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2k, False: 0]
  ------------------
  157|  13.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  13.2k|         (void)m( result );
  163|  13.2k|         return result;
  164|  13.2k|      }
  165|  13.2k|   }
_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|  13.2k|      {
   73|  13.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|  13.2k|         else {
   84|  13.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2k|      }
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|  13.2k|      {
   44|  13.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.2k|      }
_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|   834k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   834k|      else {
  108|   834k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   834k|         using iterator_t = typename ParseInput::iterator_t;
  111|   834k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   834k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   834k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   834k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   834k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   834k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   834k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   834k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   834k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   834k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   834k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   834k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   834k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   834k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   834k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   834k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   834k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   834k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 821k, False: 13.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   821k|            else if constexpr( has_apply0_bool ) {
  153|   821k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   821k|            }
  155|   821k|         }
  156|   834k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 821k, False: 13.2k]
  ------------------
  157|   821k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   821k|         }
  159|  13.2k|         else {
  160|  13.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2k|         }
  162|   834k|         (void)m( result );
  163|   834k|         return result;
  164|   834k|      }
  165|   834k|   }
_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|   834k|      {
   73|   834k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   834k|         else {
   84|   834k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   834k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   834k|      }
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|   834k|      {
   44|   834k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   834k|      }
_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|   834k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   834k|      else {
  108|   834k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   834k|         using iterator_t = typename ParseInput::iterator_t;
  111|   834k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   834k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   834k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   834k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   834k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   834k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   834k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   834k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   834k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   834k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   834k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   834k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   834k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   834k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   834k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   834k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   834k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   834k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 821k, False: 13.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   821k|            else if constexpr( has_apply0_bool ) {
  153|   821k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   821k|            }
  155|   821k|         }
  156|   834k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 821k, False: 13.2k]
  ------------------
  157|   821k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   821k|         }
  159|  13.2k|         else {
  160|  13.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2k|         }
  162|   834k|         (void)m( result );
  163|   834k|         return result;
  164|   834k|      }
  165|   834k|   }
_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|   834k|      {
   73|   834k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   834k|         else {
   84|   834k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   834k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   834k|      }
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|   834k|      {
   44|   834k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   834k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   834k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   834k|      else {
  108|   834k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   834k|         using iterator_t = typename ParseInput::iterator_t;
  111|   834k|         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: 834k]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   834k|         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: 834k]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   834k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   834k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded, False: 834k]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   834k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded, False: 834k]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   834k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   834k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   834k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   834k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   834k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   834k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   834k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   834k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   834k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   834k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   834k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   834k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   834k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2k, False: 821k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  13.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.2k|            }
  155|  13.2k|         }
  156|   834k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2k, False: 821k]
  ------------------
  157|  13.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2k|         }
  159|   821k|         else {
  160|   821k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   821k|         }
  162|   834k|         (void)m( result );
  163|   834k|         return result;
  164|   834k|      }
  165|   834k|   }
_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|   834k|      {
   73|   834k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   834k|         else {
   84|   834k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   834k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   834k|      }
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|   834k|      {
   59|   834k|         return Rule::match( in );
   60|   834k|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   821k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   821k|      else {
  108|   821k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   821k|         using iterator_t = typename ParseInput::iterator_t;
  111|   821k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   821k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   821k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   821k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   821k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   821k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   821k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   821k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   821k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   821k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   821k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   821k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   821k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   821k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   821k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   821k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   821k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   821k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 821k, 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|   821k|            else if constexpr( has_apply0_bool ) {
  153|   821k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   821k|            }
  155|   821k|         }
  156|   821k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 821k, False: 0]
  ------------------
  157|   821k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   821k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   821k|         (void)m( result );
  163|   821k|         return result;
  164|   821k|      }
  165|   821k|   }
_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|   821k|      {
   73|   821k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   821k|         else {
   84|   821k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   821k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   821k|      }
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|   821k|      {
   59|   821k|         return Rule::match( in );
   60|   821k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 37.7k, False: 4.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|  37.7k|            else if constexpr( has_apply0_bool ) {
  153|  37.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.7k|            }
  155|  37.7k|         }
  156|  42.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.7k, False: 4.72k]
  ------------------
  157|  37.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.7k|         }
  159|  4.72k|         else {
  160|  4.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.72k|         }
  162|  42.4k|         (void)m( result );
  163|  42.4k|         return result;
  164|  42.4k|      }
  165|  42.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  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_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|  42.4k|      {
   44|  42.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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): [True: 0, Folded]
  ------------------
  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): [True: 42.4k, Folded]
  |  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): [True: 42.4k, Folded]
  |  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.3k, False: 108]
  ------------------
  143|  42.3k|            if constexpr( has_apply_void ) {
  144|  42.3k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  42.3k|         }
  156|  42.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.3k, False: 108]
  ------------------
  157|  42.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.3k|         }
  159|    108|         else {
  160|    108|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    108|         }
  162|  42.4k|         (void)m( result );
  163|  42.4k|         return result;
  164|  42.4k|      }
  165|  42.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  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_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|  42.4k|      {
   44|  42.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  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: 38.6k, False: 3.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.6k|            else if constexpr( has_apply0_bool ) {
  153|  38.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.6k|            }
  155|  38.6k|         }
  156|  42.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.6k, False: 3.81k]
  ------------------
  157|  38.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.6k|         }
  159|  3.81k|         else {
  160|  3.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.81k|         }
  162|  42.4k|         (void)m( result );
  163|  42.4k|         return result;
  164|  42.4k|      }
  165|  42.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  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_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|  42.4k|      {
   59|  42.4k|         return Rule::match( in );
   60|  42.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.81k|      else {
  108|  3.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.80k, False: 1.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|  2.80k|            else if constexpr( has_apply0_bool ) {
  153|  2.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.80k|            }
  155|  2.80k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.80k, False: 1.01k]
  ------------------
  157|  2.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.80k|         }
  159|  1.01k|         else {
  160|  1.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.01k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.81k|      {
   73|  3.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.81k|         else {
   84|  3.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.81k|      }
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.81k|      {
   59|  3.81k|         return Rule::match( in );
   60|  3.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.01k|      else {
  108|  1.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.01k|         constexpr bool has_apply_void = enable_action && internal::has_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.01k|         constexpr bool has_apply_bool = enable_action && internal::has_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.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9, False: 1.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|      9|            else if constexpr( has_apply0_bool ) {
  153|      9|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|      9|            }
  155|      9|         }
  156|  1.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9, False: 1.00k]
  ------------------
  157|      9|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|      9|         }
  159|  1.00k|         else {
  160|  1.00k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.00k|         }
  162|  1.01k|         (void)m( result );
  163|  1.01k|         return result;
  164|  1.01k|      }
  165|  1.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.01k|      {
   73|  1.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  1.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.01k|      {
   59|  1.01k|         return Rule::match( in );
   60|  1.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.00k|      else {
  108|  1.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 851, False: 150]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    851|            else if constexpr( has_apply0_bool ) {
  153|    851|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    851|            }
  155|    851|         }
  156|  1.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 851, False: 150]
  ------------------
  157|    851|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    851|         }
  159|    150|         else {
  160|    150|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    150|         }
  162|  1.00k|         (void)m( result );
  163|  1.00k|         return result;
  164|  1.00k|      }
  165|  1.00k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.00k|      {
   73|  1.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|  1.00k|         else {
   84|  1.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.00k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.00k|      {
   59|  1.00k|         return Rule::match( in );
   60|  1.00k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    150|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    150|      else {
  108|    150|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    150|         using iterator_t = typename ParseInput::iterator_t;
  111|    150|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    150|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    150|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    150|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    150|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    150|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    150|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    150|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    150|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    150|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    150|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    150|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    150|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    150|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    150|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    150|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    150|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    150|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42, False: 108]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|            else if constexpr( has_apply0_bool ) {
  153|     42|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     42|            }
  155|     42|         }
  156|    150|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42, False: 108]
  ------------------
  157|     42|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     42|         }
  159|    108|         else {
  160|    108|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    108|         }
  162|    150|         (void)m( result );
  163|    150|         return result;
  164|    150|      }
  165|    150|   }
_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|    150|      {
   73|    150|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    150|         else {
   84|    150|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    150|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    150|      }
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|    150|      {
   59|    150|         return Rule::match( in );
   60|    150|      }
_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|  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: 42.3k, False: 4]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  42.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.3k|            }
  155|  42.3k|         }
  156|  42.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.3k, False: 4]
  ------------------
  157|  42.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.3k|         }
  159|      4|         else {
  160|      4|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      4|         }
  162|  42.3k|         (void)m( result );
  163|  42.3k|         return result;
  164|  42.3k|      }
  165|  42.3k|   }
_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|  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_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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_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|  42.3k|   {
  104|  42.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  42.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|  42.3k|   }
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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 87.5k, False: 28.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|  87.5k|            else if constexpr( has_apply0_bool ) {
  153|  87.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  87.5k|            }
  155|  87.5k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 87.5k, False: 28.8k]
  ------------------
  157|  87.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  87.5k|         }
  159|  28.8k|         else {
  160|  28.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.8k|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_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|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   116k|         else {
   84|   116k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   116k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   116k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   116k|      {
   44|   116k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   116k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   116k|      else {
  108|   116k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   116k|         using iterator_t = typename ParseInput::iterator_t;
  111|   116k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   116k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   116k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   116k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   116k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   116k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   116k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   116k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   116k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   116k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   116k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   116k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   116k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   116k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 87.5k, False: 28.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|  87.5k|            else if constexpr( has_apply0_bool ) {
  153|  87.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  87.5k|            }
  155|  87.5k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 87.5k, False: 28.8k]
  ------------------
  157|  87.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  87.5k|         }
  159|  28.8k|         else {
  160|  28.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.8k|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_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|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   116k|         else {
   84|   116k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   116k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   116k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   116k|      {
   59|   116k|         return Rule::match( in );
   60|   116k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_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): [True: 0, Folded]
  ------------------
  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): [True: 42.3k, Folded]
  |  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): [True: 42.3k, Folded]
  |  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: 3.56k, False: 38.7k]
  ------------------
  143|  3.56k|            if constexpr( has_apply_void ) {
  144|  3.56k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.56k|         }
  156|  42.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.56k, False: 38.7k]
  ------------------
  157|  3.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.56k|         }
  159|  38.7k|         else {
  160|  38.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.7k|         }
  162|  42.3k|         (void)m( result );
  163|  42.3k|         return result;
  164|  42.3k|      }
  165|  42.3k|   }
_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|  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_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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_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: 3.60k, False: 38.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.60k|            else if constexpr( has_apply0_bool ) {
  153|  3.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.60k|            }
  155|  3.60k|         }
  156|  42.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.60k, False: 38.7k]
  ------------------
  157|  3.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.60k|         }
  159|  38.7k|         else {
  160|  38.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.7k|         }
  162|  42.3k|         (void)m( result );
  163|  42.3k|         return result;
  164|  42.3k|      }
  165|  42.3k|   }
_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|  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_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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 4.00k, False: 41.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.00k|            else if constexpr( has_apply0_bool ) {
  153|  4.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.00k|            }
  155|  4.00k|         }
  156|  45.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.00k, False: 41.9k]
  ------------------
  157|  4.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.00k|         }
  159|  41.9k|         else {
  160|  41.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.9k|         }
  162|  45.9k|         (void)m( result );
  163|  45.9k|         return result;
  164|  45.9k|      }
  165|  45.9k|   }
_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|  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_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|  45.9k|      {
   44|  45.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  58.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  58.0k|      else {
  108|  58.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  58.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  58.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|  58.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|  58.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|  58.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|  58.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|  58.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|  58.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  58.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  58.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  58.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|  58.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  58.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  58.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|  58.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  58.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  58.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  58.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  58.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.0k, False: 41.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.0k|            else if constexpr( has_apply0_bool ) {
  153|  16.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.0k|            }
  155|  16.0k|         }
  156|  58.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.0k, False: 41.9k]
  ------------------
  157|  16.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.0k|         }
  159|  41.9k|         else {
  160|  41.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.9k|         }
  162|  58.0k|         (void)m( result );
  163|  58.0k|         return result;
  164|  58.0k|      }
  165|  58.0k|   }
_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|  58.0k|      {
   73|  58.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|  58.0k|         else {
   84|  58.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  58.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  58.0k|      }
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|  58.0k|      {
   59|  58.0k|         return Rule::match( in );
   60|  58.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  41.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.9k|      else {
  108|  41.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.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|  41.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|  41.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|  41.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|  41.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|  41.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|  41.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.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|  41.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.17k, False: 38.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.17k|            else if constexpr( has_apply0_bool ) {
  153|  3.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.17k|            }
  155|  3.17k|         }
  156|  41.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.17k, False: 38.7k]
  ------------------
  157|  3.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.17k|         }
  159|  38.7k|         else {
  160|  38.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.7k|         }
  162|  41.9k|         (void)m( result );
  163|  41.9k|         return result;
  164|  41.9k|      }
  165|  41.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|  41.9k|      {
   73|  41.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|  41.9k|         else {
   84|  41.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.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|  41.9k|      {
   59|  41.9k|         return Rule::match( in );
   60|  41.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.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.60k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.58k, False: 28]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.58k|            else if constexpr( has_apply0_bool ) {
  153|  3.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.58k|            }
  155|  3.58k|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.58k, False: 28]
  ------------------
  157|  3.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.58k|         }
  159|     28|         else {
  160|     28|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     28|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_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.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.60k|      {
   59|  3.60k|         return Rule::match( in );
   60|  3.60k|      }
_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.58k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.56k, False: 11]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.56k, False: 11]
  ------------------
  157|  3.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.56k|         }
  159|     11|         else {
  160|     11|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     11|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_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.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.58k|      {
   44|  3.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.58k|      }
_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|  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: 37.7k, False: 4.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  37.7k|            else if constexpr( has_apply0_bool ) {
  153|  37.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.7k|            }
  155|  37.7k|         }
  156|  42.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.7k, False: 4.61k]
  ------------------
  157|  37.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.7k|         }
  159|  4.61k|         else {
  160|  4.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.61k|         }
  162|  42.3k|         (void)m( result );
  163|  42.3k|         return result;
  164|  42.3k|      }
  165|  42.3k|   }
_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|  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_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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_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|  42.3k|   {
  104|  42.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  42.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|  42.3k|   }
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|  42.3k|      {
   44|  42.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.3k|      }
_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|  39.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.6k|      else {
  108|  39.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.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|  39.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|  39.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|  39.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|  39.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|  39.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|  39.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.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|  39.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.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|  39.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.3k, False: 11.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|  28.3k|            else if constexpr( has_apply0_bool ) {
  153|  28.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.3k|            }
  155|  28.3k|         }
  156|  39.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.3k, False: 11.3k]
  ------------------
  157|  28.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.3k|         }
  159|  11.3k|         else {
  160|  11.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.3k|         }
  162|  39.6k|         (void)m( result );
  163|  39.6k|         return result;
  164|  39.6k|      }
  165|  39.6k|   }
_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|  39.6k|      {
   73|  39.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|  39.6k|         else {
   84|  39.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.6k|      }
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|  39.6k|      {
   44|  39.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.2k|      else {
  108|  45.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.6k, False: 13.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|  31.6k|            else if constexpr( has_apply0_bool ) {
  153|  31.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.6k|            }
  155|  31.6k|         }
  156|  45.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.6k, False: 13.5k]
  ------------------
  157|  31.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.6k|         }
  159|  13.5k|         else {
  160|  13.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.5k|         }
  162|  45.2k|         (void)m( result );
  163|  45.2k|         return result;
  164|  45.2k|      }
  165|  45.2k|   }
_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|  45.2k|      {
   73|  45.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|  45.2k|         else {
   84|  45.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.2k|      }
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|  45.2k|      {
   44|  45.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.2k|      else {
  108|  45.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 42.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.21k|            else if constexpr( has_apply0_bool ) {
  153|  3.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.21k|            }
  155|  3.21k|         }
  156|  45.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 42.0k]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|  42.0k|         else {
  160|  42.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.0k|         }
  162|  45.2k|         (void)m( result );
  163|  45.2k|         return result;
  164|  45.2k|      }
  165|  45.2k|   }
_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|  45.2k|      {
   73|  45.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|  45.2k|         else {
   84|  45.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.2k|      }
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|  45.2k|      {
   44|  45.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.2k|      }
_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|  45.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.2k|      else {
  108|  45.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 42.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.21k|            else if constexpr( has_apply0_bool ) {
  153|  3.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.21k|            }
  155|  3.21k|         }
  156|  45.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 42.0k]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|  42.0k|         else {
  160|  42.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.0k|         }
  162|  45.2k|         (void)m( result );
  163|  45.2k|         return result;
  164|  45.2k|      }
  165|  45.2k|   }
_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|  45.2k|      {
   73|  45.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|  45.2k|         else {
   84|  45.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.2k|      }
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|  45.2k|      {
   44|  45.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.2k|      else {
  108|  45.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  45.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|  45.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 45.2k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  45.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|  45.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|  45.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|  45.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 45.2k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.69k, False: 41.5k]
  ------------------
  143|  3.69k|            if constexpr( has_apply_void ) {
  144|  3.69k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.69k|         }
  156|  45.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.69k, False: 41.5k]
  ------------------
  157|  3.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.69k|         }
  159|  41.5k|         else {
  160|  41.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.5k|         }
  162|  45.2k|         (void)m( result );
  163|  45.2k|         return result;
  164|  45.2k|      }
  165|  45.2k|   }
_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|  45.2k|      {
   73|  45.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|  45.2k|         else {
   84|  45.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.2k|      }
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|  45.2k|      {
   59|  45.2k|         return Rule::match( in );
   60|  45.2k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   796k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   796k|      else {
  108|   796k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   796k|         using iterator_t = typename ParseInput::iterator_t;
  111|   796k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   796k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   796k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   796k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   796k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   796k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   796k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   796k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   796k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   796k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   796k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   796k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   796k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   796k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   796k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   796k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   796k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   796k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 795k, 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|   795k|            else if constexpr( has_apply0_bool ) {
  153|   795k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   795k|            }
  155|   795k|         }
  156|   796k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 795k, False: 1.23k]
  ------------------
  157|   795k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   795k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|   796k|         (void)m( result );
  163|   796k|         return result;
  164|   796k|      }
  165|   796k|   }
_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|   796k|      {
   73|   796k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   796k|         else {
   84|   796k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   796k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   796k|      }
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|   796k|      {
   44|   796k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   796k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   796k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   796k|      else {
  108|   796k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   796k|         using iterator_t = typename ParseInput::iterator_t;
  111|   796k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   796k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   796k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   796k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   796k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   796k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   796k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   796k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   796k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   796k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   796k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   796k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   796k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   796k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   796k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   796k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   796k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   796k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 795k, 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|   795k|            else if constexpr( has_apply0_bool ) {
  153|   795k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   795k|            }
  155|   795k|         }
  156|   796k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 795k, False: 1.23k]
  ------------------
  157|   795k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   795k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|   796k|         (void)m( result );
  163|   796k|         return result;
  164|   796k|      }
  165|   796k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   796k|      {
   73|   796k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   796k|         else {
   84|   796k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   796k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   796k|      }
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|   796k|      {
   59|   796k|         return Rule::match( in );
   60|   796k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.95k, False: 800k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.95k|            else if constexpr( has_apply0_bool ) {
  153|  7.95k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.95k|            }
  155|  7.95k|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.95k, False: 800k]
  ------------------
  157|  7.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.95k|         }
  159|   800k|         else {
  160|   800k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   800k|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   59|   808k|         return Rule::match( in );
   60|   808k|      }
_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.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.21k, False: 458]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.21k|            else if constexpr( has_apply0_bool ) {
  153|  3.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.21k|            }
  155|  3.21k|         }
  156|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 458]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|    458|         else {
  160|    458|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    458|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_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.67k|      {
   44|  3.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.67k|      }
_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.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: 2.16k, False: 1.50k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.16k|            else if constexpr( has_apply0_bool ) {
  153|  2.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.16k|            }
  155|  2.16k|         }
  156|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.16k, False: 1.50k]
  ------------------
  157|  2.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.16k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_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.67k|      {
   44|  3.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.67k|      }
_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.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.67k, 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.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|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 0]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_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.67k|      {
   44|  3.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.67k|      }
_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.67k|   {
  104|  3.67k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.67k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.67k|   }
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.67k|      {
   44|  3.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.67k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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): [True: 0, Folded]
  ------------------
  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): [True: 3.67k, Folded]
  |  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): [True: 3.67k, Folded]
  |  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: 1.65k, False: 2.02k]
  ------------------
  143|  1.65k|            if constexpr( has_apply_void ) {
  144|  1.65k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.65k|         }
  156|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.65k, False: 2.02k]
  ------------------
  157|  1.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.65k|         }
  159|  2.02k|         else {
  160|  2.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.02k|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_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.67k|      {
   44|  3.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.67k|      }
_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.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: 226, False: 3.44k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 226, False: 3.44k]
  ------------------
  157|    226|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    226|         }
  159|  3.44k|         else {
  160|  3.44k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.44k|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_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.67k|      {
   59|  3.67k|         return Rule::match( in );
   60|  3.67k|      }
_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.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.44k|      else {
  108|  3.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.44k|         constexpr bool has_apply_void = enable_action && internal::has_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.44k|         constexpr bool has_apply_bool = enable_action && internal::has_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.44k|         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.44k|         constexpr bool has_apply0_void = enable_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.44k|         constexpr bool has_apply0_bool = enable_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.44k|         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.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 3.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|    212|            else if constexpr( has_apply0_bool ) {
  153|    212|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    212|            }
  155|    212|         }
  156|  3.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 3.23k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  3.23k|         else {
  160|  3.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.23k|         }
  162|  3.44k|         (void)m( result );
  163|  3.44k|         return result;
  164|  3.44k|      }
  165|  3.44k|   }
_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.44k|      {
   73|  3.44k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.44k|         else {
   84|  3.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.44k|      }
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.44k|      {
   59|  3.44k|         return Rule::match( in );
   60|  3.44k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.23k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.23k|      else {
  108|  3.23k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.23k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.23k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.23k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.23k|         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.23k|         constexpr bool has_apply0_void = enable_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.23k|         constexpr bool has_apply0_bool = enable_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.23k|         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.23k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.23k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.23k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.23k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.23k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.23k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.23k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.23k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.23k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.23k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.23k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.23k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 3.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|    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.23k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.04k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.04k|         else {
  160|  3.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.04k|         }
  162|  3.23k|         (void)m( result );
  163|  3.23k|         return result;
  164|  3.23k|      }
  165|  3.23k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.23k|      {
   73|  3.23k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.23k|         else {
   84|  3.23k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.23k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.23k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.23k|      {
   59|  3.23k|         return Rule::match( in );
   60|  3.23k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.04k|      else {
  108|  3.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 222, False: 2.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  3.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 222, False: 2.81k]
  ------------------
  157|    222|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    222|         }
  159|  2.81k|         else {
  160|  2.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.81k|         }
  162|  3.04k|         (void)m( result );
  163|  3.04k|         return result;
  164|  3.04k|      }
  165|  3.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.04k|      {
   73|  3.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|  3.04k|         else {
   84|  3.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.04k|      {
   59|  3.04k|         return Rule::match( in );
   60|  3.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 602, False: 2.21k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    602|            else if constexpr( has_apply0_bool ) {
  153|    602|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    602|            }
  155|    602|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 602, False: 2.21k]
  ------------------
  157|    602|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    602|         }
  159|  2.21k|         else {
  160|  2.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.21k|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_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.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.81k|      {
   59|  2.81k|         return Rule::match( in );
   60|  2.81k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.21k|      else {
  108|  2.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, 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|    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.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.02k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.02k|         else {
  160|  2.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.02k|         }
  162|  2.21k|         (void)m( result );
  163|  2.21k|         return result;
  164|  2.21k|      }
  165|  2.21k|   }
_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.21k|      {
   73|  2.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.21k|         else {
   84|  2.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   59|  2.21k|         return Rule::match( in );
   60|  2.21k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_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: 2.40k, False: 1.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|  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|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 1.27k]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|  1.27k|         else {
  160|  1.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.27k|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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.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_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_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|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.73k|      else {
  108|  4.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.73k, 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.73k|            else if constexpr( has_apply0_bool ) {
  153|  4.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.73k|            }
  155|  4.73k|         }
  156|  4.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.73k, False: 0]
  ------------------
  157|  4.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.73k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.73k|         (void)m( result );
  163|  4.73k|         return result;
  164|  4.73k|      }
  165|  4.73k|   }
_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.73k|      {
   73|  4.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|  4.73k|         else {
   84|  4.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.73k|      }
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.73k|      {
   44|  4.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.73k|      }
_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.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.33k, False: 69]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.33k|            else if constexpr( has_apply0_bool ) {
  153|  2.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.33k|            }
  155|  2.33k|         }
  156|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.33k, False: 69]
  ------------------
  157|  2.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.33k|         }
  159|     69|         else {
  160|     69|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     69|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_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.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_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.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_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.33k|   {
  104|  2.33k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.33k|         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.33k|   }
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.33k|      {
   44|  2.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.33k|      }
_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|   791k|   {
  104|   791k|      if constexpr( !Control< Rule >::enable ) {
  105|   791k|         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|   791k|   }
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|   791k|      {
   44|   791k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   791k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.33k|      else {
  108|  2.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.16k, False: 166]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.16k|            else if constexpr( has_apply0_bool ) {
  153|  2.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.16k|            }
  155|  2.16k|         }
  156|  2.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.16k, False: 166]
  ------------------
  157|  2.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.16k|         }
  159|    166|         else {
  160|    166|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    166|         }
  162|  2.33k|         (void)m( result );
  163|  2.33k|         return result;
  164|  2.33k|      }
  165|  2.33k|   }
_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.33k|      {
   73|  2.33k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.33k|         else {
   84|  2.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.33k|      {
   59|  2.33k|         return Rule::match( in );
   60|  2.33k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   794k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   794k|      else {
  108|   794k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   794k|         using iterator_t = typename ParseInput::iterator_t;
  111|   794k|         constexpr bool has_apply_void = 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|   794k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   794k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 794k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   794k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   794k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   794k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   794k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   794k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   794k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   794k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   794k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   794k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   794k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   794k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 794k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   794k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   794k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   794k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   794k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 792k, False: 1.68k]
  ------------------
  143|   792k|            if constexpr( has_apply_void ) {
  144|   792k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   792k|         }
  156|   794k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 792k, False: 1.69k]
  ------------------
  157|   792k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   792k|         }
  159|  1.69k|         else {
  160|  1.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.69k|         }
  162|   794k|         (void)m( result );
  163|   794k|         return result;
  164|   794k|      }
  165|   794k|   }
_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|   794k|      {
   73|   794k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   794k|         else {
   84|   794k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   794k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   794k|      }
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|   794k|      {
   44|   794k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   794k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   794k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   794k|      else {
  108|   794k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   794k|         using iterator_t = typename ParseInput::iterator_t;
  111|   794k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   794k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   794k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   794k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   794k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   794k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   794k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   794k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   794k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   794k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   794k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   794k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   794k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   794k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   794k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   794k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   794k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   794k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 792k, False: 1.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|   792k|            else if constexpr( has_apply0_bool ) {
  153|   792k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   792k|            }
  155|   792k|         }
  156|   794k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 792k, False: 1.62k]
  ------------------
  157|   792k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   792k|         }
  159|  1.62k|         else {
  160|  1.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.62k|         }
  162|   794k|         (void)m( result );
  163|   794k|         return result;
  164|   794k|      }
  165|   794k|   }
_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|   794k|      {
   73|   794k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   794k|         else {
   84|   794k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   794k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   794k|      }
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|   794k|      {
   44|   794k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   794k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.58M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.58M|      else {
  108|  1.58M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.58M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.58M|         constexpr bool has_apply_void = enable_action && internal::has_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.58M|         constexpr bool has_apply_bool = enable_action && internal::has_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.58M|         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.58M|         constexpr bool has_apply0_void = enable_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.58M|         constexpr bool has_apply0_bool = enable_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.58M|         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.58M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.58M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.58M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.58M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.58M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.58M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.58M|         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.58M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.58M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.58M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.58M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.58M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.68k, False: 1.58M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.68k|            else if constexpr( has_apply0_bool ) {
  153|  2.68k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.68k|            }
  155|  2.68k|         }
  156|  1.58M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.68k, False: 1.58M]
  ------------------
  157|  2.68k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.68k|         }
  159|  1.58M|         else {
  160|  1.58M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.58M|         }
  162|  1.58M|         (void)m( result );
  163|  1.58M|         return result;
  164|  1.58M|      }
  165|  1.58M|   }
_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.58M|      {
   73|  1.58M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.58M|         else {
   84|  1.58M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.58M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.58M|      }
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.58M|      {
   44|  1.58M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.58M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.59M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.59M|      else {
  108|  1.59M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.59M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.59M|         constexpr bool has_apply_void = enable_action && internal::has_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.59M|         constexpr bool has_apply_bool = enable_action && internal::has_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.59M|         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.59M|         constexpr bool has_apply0_void = enable_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.59M|         constexpr bool has_apply0_bool = enable_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.59M|         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.59M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.59M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.59M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.59M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.59M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.59M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.59M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.59M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.59M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.59M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.59M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.59M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.9k, False: 1.58M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  10.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.9k|            }
  155|  10.9k|         }
  156|  1.59M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.9k, False: 1.58M]
  ------------------
  157|  10.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.9k|         }
  159|  1.58M|         else {
  160|  1.58M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.58M|         }
  162|  1.59M|         (void)m( result );
  163|  1.59M|         return result;
  164|  1.59M|      }
  165|  1.59M|   }
_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.59M|      {
   73|  1.59M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.59M|         else {
   84|  1.59M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.59M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.59M|      }
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.59M|      {
   59|  1.59M|         return Rule::match( in );
   60|  1.59M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.58M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.58M|      else {
  108|  1.58M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.58M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.58M|         constexpr bool has_apply_void = enable_action && internal::has_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.58M|         constexpr bool has_apply_bool = enable_action && internal::has_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.58M|         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.58M|         constexpr bool has_apply0_void = enable_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.58M|         constexpr bool has_apply0_bool = enable_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.58M|         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.58M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.58M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.58M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.58M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.58M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.58M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.58M|         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.58M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.58M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.58M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.58M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.58M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.58M, False: 1.64k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.58M|            else if constexpr( has_apply0_bool ) {
  153|  1.58M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.58M|            }
  155|  1.58M|         }
  156|  1.58M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.58M, False: 1.64k]
  ------------------
  157|  1.58M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.58M|         }
  159|  1.64k|         else {
  160|  1.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.64k|         }
  162|  1.58M|         (void)m( result );
  163|  1.58M|         return result;
  164|  1.58M|      }
  165|  1.58M|   }
_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.58M|      {
   73|  1.58M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.58M|         else {
   84|  1.58M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.58M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.58M|      }
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.58M|      {
   59|  1.58M|         return Rule::match( in );
   60|  1.58M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   792k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   792k|      else {
  108|   792k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   792k|         using iterator_t = typename ParseInput::iterator_t;
  111|   792k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   792k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   792k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   792k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   792k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   792k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   792k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   792k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   792k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   792k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   792k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   792k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   792k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   792k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   792k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   792k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   792k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   792k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 792k, False: 44]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   792k|            else if constexpr( has_apply0_bool ) {
  153|   792k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   792k|            }
  155|   792k|         }
  156|   792k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 792k, False: 44]
  ------------------
  157|   792k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   792k|         }
  159|     44|         else {
  160|     44|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     44|         }
  162|   792k|         (void)m( result );
  163|   792k|         return result;
  164|   792k|      }
  165|   792k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   792k|      {
   73|   792k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   792k|         else {
   84|   792k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   792k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   792k|      }
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|   792k|      {
   59|   792k|         return Rule::match( in );
   60|   792k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   792k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   792k|      else {
  108|   792k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   792k|         using iterator_t = typename ParseInput::iterator_t;
  111|   792k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   792k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   792k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   792k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   792k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   792k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   792k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   792k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   792k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   792k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   792k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   792k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   792k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   792k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   792k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   792k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   792k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   792k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 792k, 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|   792k|            else if constexpr( has_apply0_bool ) {
  153|   792k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   792k|            }
  155|   792k|         }
  156|   792k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 792k, False: 20]
  ------------------
  157|   792k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   792k|         }
  159|     20|         else {
  160|     20|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     20|         }
  162|   792k|         (void)m( result );
  163|   792k|         return result;
  164|   792k|      }
  165|   792k|   }
_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|   792k|      {
   73|   792k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   792k|         else {
   84|   792k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   792k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   792k|      }
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|   792k|      {
   44|   792k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   792k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  42.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.0k|      else {
  108|  42.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.77k, False: 38.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.77k|            else if constexpr( has_apply0_bool ) {
  153|  3.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.77k|            }
  155|  3.77k|         }
  156|  42.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.77k, False: 38.2k]
  ------------------
  157|  3.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.77k|         }
  159|  38.2k|         else {
  160|  38.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.2k|         }
  162|  42.0k|         (void)m( result );
  163|  42.0k|         return result;
  164|  42.0k|      }
  165|  42.0k|   }
_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|  42.0k|      {
   73|  42.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|  42.0k|         else {
   84|  42.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.0k|      }
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|  42.0k|      {
   44|  42.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.0k|      }
_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|  42.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.0k|      else {
  108|  42.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.77k, False: 38.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.77k|            else if constexpr( has_apply0_bool ) {
  153|  3.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.77k|            }
  155|  3.77k|         }
  156|  42.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.77k, False: 38.2k]
  ------------------
  157|  3.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.77k|         }
  159|  38.2k|         else {
  160|  38.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.2k|         }
  162|  42.0k|         (void)m( result );
  163|  42.0k|         return result;
  164|  42.0k|      }
  165|  42.0k|   }
_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|  42.0k|      {
   73|  42.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|  42.0k|         else {
   84|  42.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.0k|      }
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|  42.0k|      {
   44|  42.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  42.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.0k|      else {
  108|  42.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 42.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.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|  42.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|  42.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|  42.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 42.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.51k, False: 37.5k]
  ------------------
  143|  4.51k|            if constexpr( has_apply_void ) {
  144|  4.51k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.51k|         }
  156|  42.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.51k, False: 37.5k]
  ------------------
  157|  4.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.51k|         }
  159|  37.5k|         else {
  160|  37.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.5k|         }
  162|  42.0k|         (void)m( result );
  163|  42.0k|         return result;
  164|  42.0k|      }
  165|  42.0k|   }
_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|  42.0k|      {
   73|  42.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|  42.0k|         else {
   84|  42.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.0k|      }
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|  42.0k|      {
   59|  42.0k|         return Rule::match( in );
   60|  42.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   594k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   594k|      else {
  108|   594k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   594k|         using iterator_t = typename ParseInput::iterator_t;
  111|   594k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   594k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   594k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   594k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   594k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   594k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   594k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   594k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   594k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   594k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   594k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   594k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   594k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   594k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   594k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   594k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   594k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   594k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 591k, False: 2.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|   591k|            else if constexpr( has_apply0_bool ) {
  153|   591k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   591k|            }
  155|   591k|         }
  156|   594k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 591k, False: 2.83k]
  ------------------
  157|   591k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   591k|         }
  159|  2.83k|         else {
  160|  2.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.83k|         }
  162|   594k|         (void)m( result );
  163|   594k|         return result;
  164|   594k|      }
  165|   594k|   }
_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|   594k|      {
   73|   594k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   594k|         else {
   84|   594k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   594k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   594k|      }
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|   594k|      {
   44|   594k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   594k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   594k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   594k|      else {
  108|   594k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   594k|         using iterator_t = typename ParseInput::iterator_t;
  111|   594k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   594k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   594k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   594k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   594k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   594k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   594k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   594k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   594k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   594k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   594k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   594k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   594k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   594k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   594k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   594k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   594k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   594k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 591k, False: 2.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|   591k|            else if constexpr( has_apply0_bool ) {
  153|   591k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   591k|            }
  155|   591k|         }
  156|   594k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 591k, False: 2.83k]
  ------------------
  157|   591k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   591k|         }
  159|  2.83k|         else {
  160|  2.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.83k|         }
  162|   594k|         (void)m( result );
  163|   594k|         return result;
  164|   594k|      }
  165|   594k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   594k|      {
   73|   594k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   594k|         else {
   84|   594k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   594k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   594k|      }
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|   594k|      {
   59|   594k|         return Rule::match( in );
   60|   594k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   604k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   604k|      else {
  108|   604k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   604k|         using iterator_t = typename ParseInput::iterator_t;
  111|   604k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   604k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   604k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   604k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   604k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   604k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   604k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   604k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   604k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   604k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   604k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   604k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   604k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   604k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   604k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   604k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   604k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   604k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.13k, False: 598k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.13k|            else if constexpr( has_apply0_bool ) {
  153|  6.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.13k|            }
  155|  6.13k|         }
  156|   604k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.13k, False: 598k]
  ------------------
  157|  6.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.13k|         }
  159|   598k|         else {
  160|   598k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   598k|         }
  162|   604k|         (void)m( result );
  163|   604k|         return result;
  164|   604k|      }
  165|   604k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   604k|      {
   73|   604k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   604k|         else {
   84|   604k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   604k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   604k|      }
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|   604k|      {
   59|   604k|         return Rule::match( in );
   60|   604k|      }
_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.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.77k, False: 722]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.77k|            else if constexpr( has_apply0_bool ) {
  153|  3.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.77k|            }
  155|  3.77k|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.77k, False: 722]
  ------------------
  157|  3.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.77k|         }
  159|    722|         else {
  160|    722|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    722|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   44|  4.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.49k|      }
_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.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.30k, False: 1.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.30k|            else if constexpr( has_apply0_bool ) {
  153|  3.30k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.30k|            }
  155|  3.30k|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.30k, False: 1.19k]
  ------------------
  157|  3.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.30k|         }
  159|  1.19k|         else {
  160|  1.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.19k|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   44|  4.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.49k|      }
_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.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.49k, 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.49k|            else if constexpr( has_apply0_bool ) {
  153|  4.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.49k|            }
  155|  4.49k|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.49k, False: 0]
  ------------------
  157|  4.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.49k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   44|  4.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.49k|      }
_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.49k|   {
  104|  4.49k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.49k|         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.49k|   }
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.49k|      {
   44|  4.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.49k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = 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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.49k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.49k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.36k, False: 2.13k]
  ------------------
  143|  2.36k|            if constexpr( has_apply_void ) {
  144|  2.36k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.36k|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.36k, False: 2.13k]
  ------------------
  157|  2.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.36k|         }
  159|  2.13k|         else {
  160|  2.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.13k|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   44|  4.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.49k|      }
_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.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 379, 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|    379|            else if constexpr( has_apply0_bool ) {
  153|    379|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    379|            }
  155|    379|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 379, False: 4.11k]
  ------------------
  157|    379|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    379|         }
  159|  4.11k|         else {
  160|  4.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.11k|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   59|  4.49k|         return Rule::match( in );
   60|  4.49k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_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: 419, False: 3.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    419|            else if constexpr( has_apply0_bool ) {
  153|    419|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    419|            }
  155|    419|         }
  156|  4.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 419, False: 3.69k]
  ------------------
  157|    419|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    419|         }
  159|  3.69k|         else {
  160|  3.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.69k|         }
  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_12name_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_12name_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_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.69k|      else {
  108|  3.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.69k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 809, False: 2.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    809|            else if constexpr( has_apply0_bool ) {
  153|    809|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    809|            }
  155|    809|         }
  156|  3.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 809, False: 2.88k]
  ------------------
  157|    809|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    809|         }
  159|  2.88k|         else {
  160|  2.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.88k|         }
  162|  3.69k|         (void)m( result );
  163|  3.69k|         return result;
  164|  3.69k|      }
  165|  3.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.69k|      {
   73|  3.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.69k|         else {
   84|  3.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.69k|      {
   59|  3.69k|         return Rule::match( in );
   60|  3.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88k|      else {
  108|  2.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.69k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.69k|         else {
  160|  2.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.69k|         }
  162|  2.88k|         (void)m( result );
  163|  2.88k|         return result;
  164|  2.88k|      }
  165|  2.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.88k|      {
   73|  2.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.88k|         else {
   84|  2.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.88k|      {
   59|  2.88k|         return Rule::match( in );
   60|  2.88k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.69k|      else {
  108|  2.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.69k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 352, False: 2.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    352|            else if constexpr( has_apply0_bool ) {
  153|    352|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    352|            }
  155|    352|         }
  156|  2.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 352, False: 2.34k]
  ------------------
  157|    352|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    352|         }
  159|  2.34k|         else {
  160|  2.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.34k|         }
  162|  2.69k|         (void)m( result );
  163|  2.69k|         return result;
  164|  2.69k|      }
  165|  2.69k|   }
_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.69k|      {
   73|  2.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.69k|         else {
   84|  2.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.69k|      {
   59|  2.69k|         return Rule::match( in );
   60|  2.69k|      }
_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.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.34k|      else {
  108|  2.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 211, False: 2.13k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    211|            else if constexpr( has_apply0_bool ) {
  153|    211|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    211|            }
  155|    211|         }
  156|  2.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 211, False: 2.13k]
  ------------------
  157|    211|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    211|         }
  159|  2.13k|         else {
  160|  2.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.13k|         }
  162|  2.34k|         (void)m( result );
  163|  2.34k|         return result;
  164|  2.34k|      }
  165|  2.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.34k|      {
   73|  2.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.34k|         else {
   84|  2.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.34k|      {
   59|  2.34k|         return Rule::match( in );
   60|  2.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.49k|      else {
  108|  4.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.51k, False: 982]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.51k|            else if constexpr( has_apply0_bool ) {
  153|  3.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.51k|            }
  155|  3.51k|         }
  156|  4.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.51k, False: 982]
  ------------------
  157|  3.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.51k|         }
  159|    982|         else {
  160|    982|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    982|         }
  162|  4.49k|         (void)m( result );
  163|  4.49k|         return result;
  164|  4.49k|      }
  165|  4.49k|   }
_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.49k|      {
   73|  4.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  4.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.49k|      }
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.49k|      {
   59|  4.49k|         return Rule::match( in );
   60|  4.49k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.95k|      else {
  108|  6.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.95k|         constexpr bool has_apply_void = enable_action && internal::has_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.95k|         constexpr bool has_apply_bool = enable_action && internal::has_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.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.95k, 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.95k|            else if constexpr( has_apply0_bool ) {
  153|  6.95k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.95k|            }
  155|  6.95k|         }
  156|  6.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.95k, False: 0]
  ------------------
  157|  6.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.95k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.95k|         (void)m( result );
  163|  6.95k|         return result;
  164|  6.95k|      }
  165|  6.95k|   }
_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.95k|      {
   73|  6.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  6.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.95k|      }
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.95k|      {
   44|  6.95k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.95k|      }
_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.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.44k, False: 74]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.44k|            else if constexpr( has_apply0_bool ) {
  153|  3.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.44k|            }
  155|  3.44k|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.44k, False: 74]
  ------------------
  157|  3.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.44k|         }
  159|     74|         else {
  160|     74|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     74|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_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.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_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.46k|   {
  104|  3.46k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.46k|         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.46k|   }
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.46k|      {
   44|  3.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.46k|      }
_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|   587k|   {
  104|   587k|      if constexpr( !Control< Rule >::enable ) {
  105|   587k|         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|   587k|   }
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|   587k|      {
   44|   587k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   587k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.44k|      else {
  108|  3.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.44k|         constexpr bool has_apply_void = enable_action && internal::has_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.44k|         constexpr bool has_apply_bool = enable_action && internal::has_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.44k|         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.44k|         constexpr bool has_apply0_void = enable_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.44k|         constexpr bool has_apply0_bool = enable_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.44k|         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.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.30k, False: 140]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.30k|            else if constexpr( has_apply0_bool ) {
  153|  3.30k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.30k|            }
  155|  3.30k|         }
  156|  3.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.30k, False: 140]
  ------------------
  157|  3.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.30k|         }
  159|    140|         else {
  160|    140|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    140|         }
  162|  3.44k|         (void)m( result );
  163|  3.44k|         return result;
  164|  3.44k|      }
  165|  3.44k|   }
_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.44k|      {
   73|  3.44k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.44k|         else {
   84|  3.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.44k|      }
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.44k|      {
   59|  3.44k|         return Rule::match( in );
   60|  3.44k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   589k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   589k|      else {
  108|   589k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   589k|         using iterator_t = typename ParseInput::iterator_t;
  111|   589k|         constexpr bool has_apply_void = 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|   589k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   589k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 589k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   589k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   589k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   589k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   589k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   589k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   589k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   589k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   589k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   589k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   589k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   589k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 589k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   589k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   589k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   589k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   589k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 588k, False: 1.33k]
  ------------------
  143|   588k|            if constexpr( has_apply_void ) {
  144|   588k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   588k|         }
  156|   589k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 587k, False: 1.41k]
  ------------------
  157|   587k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   587k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|   589k|         (void)m( result );
  163|   589k|         return result;
  164|   589k|      }
  165|   589k|   }
_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|   589k|      {
   73|   589k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   589k|         else {
   84|   589k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   589k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   589k|      }
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|   589k|      {
   44|   589k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   589k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   589k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   589k|      else {
  108|   589k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   589k|         using iterator_t = typename ParseInput::iterator_t;
  111|   589k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   589k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   589k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   589k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   589k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   589k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   589k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   589k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   589k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   589k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   589k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   589k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   589k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   589k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   589k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   589k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   589k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   589k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 588k, 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|   588k|            else if constexpr( has_apply0_bool ) {
  153|   588k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   588k|            }
  155|   588k|         }
  156|   589k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 588k, False: 1.03k]
  ------------------
  157|   588k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   588k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|   589k|         (void)m( result );
  163|   589k|         return result;
  164|   589k|      }
  165|   589k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   589k|      {
   73|   589k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   589k|         else {
   84|   589k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   589k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   589k|      }
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|   589k|      {
   59|   589k|         return Rule::match( in );
   60|   589k|      }
_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|   588k|   {
  104|   588k|      if constexpr( !Control< Rule >::enable ) {
  105|   588k|         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|   588k|   }
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|   588k|      {
   44|   588k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   588k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   588k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   588k|      else {
  108|   588k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   588k|         using iterator_t = typename ParseInput::iterator_t;
  111|   588k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   588k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   588k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   588k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   588k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   588k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   588k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   588k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   588k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   588k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   588k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   588k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   588k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   588k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   588k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   588k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   588k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   588k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 588k, False: 303]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   588k|            else if constexpr( has_apply0_bool ) {
  153|   588k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   588k|            }
  155|   588k|         }
  156|   588k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 588k, False: 303]
  ------------------
  157|   588k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   588k|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|   588k|         (void)m( result );
  163|   588k|         return result;
  164|   588k|      }
  165|   588k|   }
_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|   588k|      {
   73|   588k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   588k|         else {
   84|   588k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   588k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   588k|      }
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|   588k|      {
   44|   588k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   588k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  18.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.0M|      else {
  108|  18.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.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|  18.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|  18.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|  18.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|  18.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 588k, False: 17.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|   588k|            else if constexpr( has_apply0_bool ) {
  153|   588k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   588k|            }
  155|   588k|         }
  156|  18.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 588k, False: 17.4M]
  ------------------
  157|   588k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   588k|         }
  159|  17.4M|         else {
  160|  17.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.4M|         }
  162|  18.0M|         (void)m( result );
  163|  18.0M|         return result;
  164|  18.0M|      }
  165|  18.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  18.0M|      {
   73|  18.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|  18.0M|         else {
   84|  18.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.0M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  18.0M|      {
   59|  18.0M|         return Rule::match( in );
   60|  18.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  17.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.4M|      else {
  108|  17.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.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|  17.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|  17.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|  17.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|  17.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|  17.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|  17.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.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|  17.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 17.4M, False: 303]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4M|            else if constexpr( has_apply0_bool ) {
  153|  17.4M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  17.4M|            }
  155|  17.4M|         }
  156|  17.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 17.4M, False: 303]
  ------------------
  157|  17.4M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  17.4M|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|  17.4M|         (void)m( result );
  163|  17.4M|         return result;
  164|  17.4M|      }
  165|  17.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  17.4M|      {
   73|  17.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|  17.4M|         else {
   84|  17.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.4M|      }
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|  17.4M|      {
   44|  17.4M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  17.4M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  17.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.4M|      else {
  108|  17.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.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|  17.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|  17.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|  17.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|  17.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|  17.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|  17.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.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|  17.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 245k, False: 17.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   245k|            else if constexpr( has_apply0_bool ) {
  153|   245k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   245k|            }
  155|   245k|         }
  156|  17.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 245k, False: 17.1M]
  ------------------
  157|   245k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   245k|         }
  159|  17.1M|         else {
  160|  17.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.1M|         }
  162|  17.4M|         (void)m( result );
  163|  17.4M|         return result;
  164|  17.4M|      }
  165|  17.4M|   }
_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|  17.4M|      {
   73|  17.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|  17.4M|         else {
   84|  17.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.4M|      }
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|  17.4M|      {
   44|  17.4M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  17.4M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  17.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.4M|      else {
  108|  17.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.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|  17.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|  17.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|  17.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|  17.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|  17.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|  17.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.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|  17.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 245k, False: 17.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   245k|            else if constexpr( has_apply0_bool ) {
  153|   245k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   245k|            }
  155|   245k|         }
  156|  17.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 245k, False: 17.1M]
  ------------------
  157|   245k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   245k|         }
  159|  17.1M|         else {
  160|  17.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.1M|         }
  162|  17.4M|         (void)m( result );
  163|  17.4M|         return result;
  164|  17.4M|      }
  165|  17.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  17.4M|      {
   73|  17.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|  17.4M|         else {
   84|  17.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.4M|      }
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|  17.4M|      {
   59|  17.4M|         return Rule::match( in );
   60|  17.4M|      }
_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|   245k|   {
  104|   245k|      if constexpr( !Control< Rule >::enable ) {
  105|   245k|         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|   245k|   }
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|   245k|      {
   44|   245k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   245k|      }
_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|   245k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   245k|      else {
  108|   245k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   245k|         using iterator_t = typename ParseInput::iterator_t;
  111|   245k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   245k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   245k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   245k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   245k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   245k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   245k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   245k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   245k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   245k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   245k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   245k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   245k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   245k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   245k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   245k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   245k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   245k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 245k, False: 84]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   245k|            else if constexpr( has_apply0_bool ) {
  153|   245k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   245k|            }
  155|   245k|         }
  156|   245k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 245k, False: 84]
  ------------------
  157|   245k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   245k|         }
  159|     84|         else {
  160|     84|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     84|         }
  162|   245k|         (void)m( result );
  163|   245k|         return result;
  164|   245k|      }
  165|   245k|   }
_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|   245k|      {
   73|   245k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   245k|         else {
   84|   245k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   245k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   245k|      }
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|   245k|      {
   44|   245k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   245k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   245k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   245k|      else {
  108|   245k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   245k|         using iterator_t = typename ParseInput::iterator_t;
  111|   245k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   245k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   245k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   245k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   245k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   245k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   245k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   245k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   245k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   245k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   245k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   245k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   245k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   245k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   245k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   245k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   245k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   245k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 102k, False: 142k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   102k|            else if constexpr( has_apply0_bool ) {
  153|   102k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   102k|            }
  155|   102k|         }
  156|   245k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 102k, False: 142k]
  ------------------
  157|   102k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   102k|         }
  159|   142k|         else {
  160|   142k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   142k|         }
  162|   245k|         (void)m( result );
  163|   245k|         return result;
  164|   245k|      }
  165|   245k|   }
_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|   245k|      {
   73|   245k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   245k|         else {
   84|   245k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   245k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   245k|      }
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|   245k|      {
   44|   245k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   245k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   245k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   245k|      else {
  108|   245k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   245k|         using iterator_t = typename ParseInput::iterator_t;
  111|   245k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   245k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   245k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   245k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   245k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   245k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   245k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   245k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   245k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   245k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   245k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   245k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   245k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   245k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   245k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   245k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   245k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   245k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 102k, False: 142k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   102k|            else if constexpr( has_apply0_bool ) {
  153|   102k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   102k|            }
  155|   102k|         }
  156|   245k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 102k, False: 142k]
  ------------------
  157|   102k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   102k|         }
  159|   142k|         else {
  160|   142k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   142k|         }
  162|   245k|         (void)m( result );
  163|   245k|         return result;
  164|   245k|      }
  165|   245k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   245k|      {
   73|   245k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   245k|         else {
   84|   245k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   245k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   245k|      }
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|   245k|      {
   59|   245k|         return Rule::match( in );
   60|   245k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   102k|   {
  104|   102k|      if constexpr( !Control< Rule >::enable ) {
  105|   102k|         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|   102k|   }
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|   102k|      {
   44|   102k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   102k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   102k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   102k|      else {
  108|   102k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   102k|         using iterator_t = typename ParseInput::iterator_t;
  111|   102k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   102k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   102k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   102k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   102k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   102k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   102k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   102k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   102k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   102k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   102k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   102k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   102k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   102k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   102k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   102k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   102k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   102k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 102k, 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|   102k|            else if constexpr( has_apply0_bool ) {
  153|   102k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   102k|            }
  155|   102k|         }
  156|   102k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 102k, False: 21]
  ------------------
  157|   102k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   102k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|   102k|         (void)m( result );
  163|   102k|         return result;
  164|   102k|      }
  165|   102k|   }
_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|   102k|      {
   73|   102k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   102k|         else {
   84|   102k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   102k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   102k|      }
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|   102k|      {
   44|   102k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   102k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   205k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   205k|      else {
  108|   205k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   205k|         using iterator_t = typename ParseInput::iterator_t;
  111|   205k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   205k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   205k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   205k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   205k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   205k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   205k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   205k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   205k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   205k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   205k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   205k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   205k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   205k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   205k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   205k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   205k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   205k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 205k, 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|   205k|            else if constexpr( has_apply0_bool ) {
  153|   205k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   205k|            }
  155|   205k|         }
  156|   205k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 205k, False: 21]
  ------------------
  157|   205k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   205k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|   205k|         (void)m( result );
  163|   205k|         return result;
  164|   205k|      }
  165|   205k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   205k|      {
   73|   205k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   205k|         else {
   84|   205k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   205k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   205k|      }
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|   205k|      {
   59|   205k|         return Rule::match( in );
   60|   205k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   142k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   142k|      else {
  108|   142k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   142k|         using iterator_t = typename ParseInput::iterator_t;
  111|   142k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   142k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   142k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   142k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   142k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   142k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   142k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   142k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   142k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   142k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   142k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   142k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   142k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   142k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   142k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   142k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   142k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   142k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, False: 103k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|   142k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 103k]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|   103k|         else {
  160|   103k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   103k|         }
  162|   142k|         (void)m( result );
  163|   142k|         return result;
  164|   142k|      }
  165|   142k|   }
_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|   142k|      {
   73|   142k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   142k|         else {
   84|   142k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   142k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   142k|      }
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|   142k|      {
   44|   142k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   142k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_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: 46.7k, False: 140k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   187k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.7k, False: 140k]
  ------------------
  157|  46.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.7k|         }
  159|   140k|         else {
  160|   140k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   140k|         }
  162|   187k|         (void)m( result );
  163|   187k|         return result;
  164|   187k|      }
  165|   187k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_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_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_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_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  39.2k|   {
  104|  39.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  39.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|  39.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.2k|      {
   44|  39.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.2k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  39.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.2k|      else {
  108|  39.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.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|  39.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|  39.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|  39.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|  39.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|  39.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|  39.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.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|  39.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.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|  39.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.2k|            else if constexpr( has_apply0_bool ) {
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|  39.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 0]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  39.2k|         (void)m( result );
  163|  39.2k|         return result;
  164|  39.2k|      }
  165|  39.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  39.2k|      {
   73|  39.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|  39.2k|         else {
   84|  39.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.2k|      {
   44|  39.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   103k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   103k|      else {
  108|   103k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   103k|         using iterator_t = typename ParseInput::iterator_t;
  111|   103k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   103k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   103k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   103k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   103k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   103k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   103k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   103k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   103k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   103k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   103k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   103k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   103k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   103k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   103k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   103k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   103k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   103k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 98.2k, False: 5.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|  98.2k|            else if constexpr( has_apply0_bool ) {
  153|  98.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  98.2k|            }
  155|  98.2k|         }
  156|   103k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 98.2k, False: 5.42k]
  ------------------
  157|  98.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  98.2k|         }
  159|  5.42k|         else {
  160|  5.42k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.42k|         }
  162|   103k|         (void)m( result );
  163|   103k|         return result;
  164|   103k|      }
  165|   103k|   }
_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|   103k|      {
   73|   103k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   103k|         else {
   84|   103k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   103k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   103k|      }
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|   103k|      {
   59|   103k|         return Rule::match( in );
   60|   103k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.42k|      else {
  108|  5.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.36k, False: 63]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.36k|            else if constexpr( has_apply0_bool ) {
  153|  5.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.36k|            }
  155|  5.36k|         }
  156|  5.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.36k, False: 63]
  ------------------
  157|  5.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.36k|         }
  159|     63|         else {
  160|     63|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     63|         }
  162|  5.42k|         (void)m( result );
  163|  5.42k|         return result;
  164|  5.42k|      }
  165|  5.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.42k|      {
   73|  5.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|  5.42k|         else {
   84|  5.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.42k|      }
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|  5.42k|      {
   59|  5.42k|         return Rule::match( in );
   60|  5.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  17.1M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.1M|      else {
  108|  17.1M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.1M|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.1M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  17.1M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  17.1M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  17.1M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  17.1M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  17.1M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  17.1M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.1M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.1M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.1M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  17.1M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.1M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.1M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  17.1M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.1M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.1M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.1M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.1M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 17.1M, False: 219]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  17.1M|            else if constexpr( has_apply0_bool ) {
  153|  17.1M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  17.1M|            }
  155|  17.1M|         }
  156|  17.1M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 17.1M, False: 219]
  ------------------
  157|  17.1M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  17.1M|         }
  159|    219|         else {
  160|    219|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    219|         }
  162|  17.1M|         (void)m( result );
  163|  17.1M|         return result;
  164|  17.1M|      }
  165|  17.1M|   }
_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|  17.1M|      {
   73|  17.1M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  17.1M|         else {
   84|  17.1M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.1M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.1M|      }
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|  17.1M|      {
   59|  17.1M|         return Rule::match( in );
   60|  17.1M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.8k|      else {
  108|  37.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, False: 34.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.45k|            else if constexpr( has_apply0_bool ) {
  153|  3.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.45k|            }
  155|  3.45k|         }
  156|  37.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.45k, False: 34.4k]
  ------------------
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|  34.4k|         else {
  160|  34.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.4k|         }
  162|  37.8k|         (void)m( result );
  163|  37.8k|         return result;
  164|  37.8k|      }
  165|  37.8k|   }
_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|  37.8k|      {
   73|  37.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|  37.8k|         else {
   84|  37.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.8k|      }
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|  37.8k|      {
   44|  37.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.8k|      }
_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|  37.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.8k|      else {
  108|  37.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, False: 34.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.45k|            else if constexpr( has_apply0_bool ) {
  153|  3.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.45k|            }
  155|  3.45k|         }
  156|  37.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.45k, False: 34.4k]
  ------------------
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|  34.4k|         else {
  160|  34.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.4k|         }
  162|  37.8k|         (void)m( result );
  163|  37.8k|         return result;
  164|  37.8k|      }
  165|  37.8k|   }
_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|  37.8k|      {
   73|  37.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|  37.8k|         else {
   84|  37.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.8k|      }
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|  37.8k|      {
   44|  37.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.8k|      else {
  108|  37.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 37.8k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.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|  37.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|  37.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|  37.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 37.8k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.20k, False: 33.6k]
  ------------------
  143|  4.20k|            if constexpr( has_apply_void ) {
  144|  4.20k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.20k|         }
  156|  37.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.20k, False: 33.6k]
  ------------------
  157|  4.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.20k|         }
  159|  33.6k|         else {
  160|  33.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.6k|         }
  162|  37.8k|         (void)m( result );
  163|  37.8k|         return result;
  164|  37.8k|      }
  165|  37.8k|   }
_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|  37.8k|      {
   73|  37.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|  37.8k|         else {
   84|  37.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.8k|      }
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|  37.8k|      {
   59|  37.8k|         return Rule::match( in );
   60|  37.8k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  12.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.6k|      else {
  108|  12.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.4k, False: 2.22k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.4k|            else if constexpr( has_apply0_bool ) {
  153|  10.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.4k|            }
  155|  10.4k|         }
  156|  12.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.4k, False: 2.22k]
  ------------------
  157|  10.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.4k|         }
  159|  2.22k|         else {
  160|  2.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.22k|         }
  162|  12.6k|         (void)m( result );
  163|  12.6k|         return result;
  164|  12.6k|      }
  165|  12.6k|   }
_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|  12.6k|      {
   73|  12.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|  12.6k|         else {
   84|  12.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6k|      }
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|  12.6k|      {
   44|  12.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  12.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  12.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.6k|      else {
  108|  12.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.4k, False: 2.22k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.4k|            else if constexpr( has_apply0_bool ) {
  153|  10.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.4k|            }
  155|  10.4k|         }
  156|  12.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.4k, False: 2.22k]
  ------------------
  157|  10.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.4k|         }
  159|  2.22k|         else {
  160|  2.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.22k|         }
  162|  12.6k|         (void)m( result );
  163|  12.6k|         return result;
  164|  12.6k|      }
  165|  12.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  12.6k|      {
   73|  12.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|  12.6k|         else {
   84|  12.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6k|      }
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|  12.6k|      {
   59|  12.6k|         return Rule::match( in );
   60|  12.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  21.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.6k|      else {
  108|  21.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.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|  21.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|  21.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|  21.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|  21.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|  21.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|  21.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.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|  21.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.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|  21.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.38k, 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.38k|            else if constexpr( has_apply0_bool ) {
  153|  5.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.38k|            }
  155|  5.38k|         }
  156|  21.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.38k, False: 16.2k]
  ------------------
  157|  5.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.38k|         }
  159|  16.2k|         else {
  160|  16.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.2k|         }
  162|  21.6k|         (void)m( result );
  163|  21.6k|         return result;
  164|  21.6k|      }
  165|  21.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  21.6k|      {
   73|  21.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|  21.6k|         else {
   84|  21.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.6k|      }
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|  21.6k|      {
   59|  21.6k|         return Rule::match( in );
   60|  21.6k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, False: 735]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45k|            else if constexpr( has_apply0_bool ) {
  153|  3.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.45k|            }
  155|  3.45k|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.45k, False: 735]
  ------------------
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|    735|         else {
  160|    735|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    735|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.72k, 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|  2.72k|            else if constexpr( has_apply0_bool ) {
  153|  2.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.72k|            }
  155|  2.72k|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.72k, False: 1.46k]
  ------------------
  157|  2.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.72k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.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|  4.18k|            else if constexpr( has_apply0_bool ) {
  153|  4.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.18k|            }
  155|  4.18k|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.18k, False: 0]
  ------------------
  157|  4.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.18k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|  4.18k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.18k|         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.18k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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): [True: 0, Folded]
  ------------------
  112|  4.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|  4.18k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.18k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.18k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.83k, False: 2.35k]
  ------------------
  143|  1.83k|            if constexpr( has_apply_void ) {
  144|  1.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.83k|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.83k, False: 2.35k]
  ------------------
  157|  1.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.83k|         }
  159|  2.35k|         else {
  160|  2.35k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.35k|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 225, False: 3.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|    225|            else if constexpr( has_apply0_bool ) {
  153|    225|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    225|            }
  155|    225|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 225, False: 3.96k]
  ------------------
  157|    225|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    225|         }
  159|  3.96k|         else {
  160|  3.96k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.96k|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.18k|      {
   59|  4.18k|         return Rule::match( in );
   60|  4.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.96k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.96k|      else {
  108|  3.96k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.96k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.96k|         constexpr bool has_apply_void = enable_action && internal::has_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.96k|         constexpr bool has_apply_bool = enable_action && internal::has_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.96k|         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.96k|         constexpr bool has_apply0_void = enable_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.96k|         constexpr bool has_apply0_bool = enable_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.96k|         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.96k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.96k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.96k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.96k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.96k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.96k|         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.96k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.96k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.96k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.96k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.96k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 547, False: 3.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    547|            else if constexpr( has_apply0_bool ) {
  153|    547|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    547|            }
  155|    547|         }
  156|  3.96k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 547, False: 3.41k]
  ------------------
  157|    547|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    547|         }
  159|  3.41k|         else {
  160|  3.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.41k|         }
  162|  3.96k|         (void)m( result );
  163|  3.96k|         return result;
  164|  3.96k|      }
  165|  3.96k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.96k|      {
   73|  3.96k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96k|         else {
   84|  3.96k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.96k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.96k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.96k|      {
   59|  3.96k|         return Rule::match( in );
   60|  3.96k|      }
_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.41k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.41k|      else {
  108|  3.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.41k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 381, 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|    381|            else if constexpr( has_apply0_bool ) {
  153|    381|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    381|            }
  155|    381|         }
  156|  3.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 381, False: 3.03k]
  ------------------
  157|    381|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    381|         }
  159|  3.03k|         else {
  160|  3.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.03k|         }
  162|  3.41k|         (void)m( result );
  163|  3.41k|         return result;
  164|  3.41k|      }
  165|  3.41k|   }
_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.41k|      {
   73|  3.41k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.41k|         else {
   84|  3.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.41k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.41k|      {
   59|  3.41k|         return Rule::match( in );
   60|  3.41k|      }
_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: 197, False: 2.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|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.83k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.83k|         else {
  160|  2.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.83k|         }
  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.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.83k|      else {
  108|  2.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.83k|         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.83k|         constexpr bool has_apply0_void = enable_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.83k|         constexpr bool has_apply0_bool = enable_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.83k|         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.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 260, False: 2.57k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 260, False: 2.57k]
  ------------------
  157|    260|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    260|         }
  159|  2.57k|         else {
  160|  2.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.57k|         }
  162|  2.83k|         (void)m( result );
  163|  2.83k|         return result;
  164|  2.83k|      }
  165|  2.83k|   }
_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.83k|      {
   73|  2.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.83k|         else {
   84|  2.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.83k|      {
   59|  2.83k|         return Rule::match( in );
   60|  2.83k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.57k|      else {
  108|  2.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 224, 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|    224|            else if constexpr( has_apply0_bool ) {
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  2.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 2.35k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  2.35k|         else {
  160|  2.35k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.35k|         }
  162|  2.57k|         (void)m( result );
  163|  2.57k|         return result;
  164|  2.57k|      }
  165|  2.57k|   }
_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.57k|      {
   73|  2.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|  2.57k|         else {
   84|  2.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.57k|      }
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.57k|      {
   59|  2.57k|         return Rule::match( in );
   60|  2.57k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.18k|      else {
  108|  4.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.95k, 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|  2.95k|            else if constexpr( has_apply0_bool ) {
  153|  2.95k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.95k|            }
  155|  2.95k|         }
  156|  4.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.95k, False: 1.23k]
  ------------------
  157|  2.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.95k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  4.18k|         (void)m( result );
  163|  4.18k|         return result;
  164|  4.18k|      }
  165|  4.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.18k|      {
   73|  4.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|  4.18k|         else {
   84|  4.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.18k|      {
   59|  4.18k|         return Rule::match( in );
   60|  4.18k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_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.82k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  5.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.82k, False: 0]
  ------------------
  157|  5.82k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.82k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.82k|         (void)m( result );
  163|  5.82k|         return result;
  164|  5.82k|      }
  165|  5.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.82k|      {
   44|  5.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.82k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.95k|      else {
  108|  2.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.95k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.95k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.87k, False: 80]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.87k|            else if constexpr( has_apply0_bool ) {
  153|  2.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.87k|            }
  155|  2.87k|         }
  156|  2.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.87k, False: 80]
  ------------------
  157|  2.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.87k|         }
  159|     80|         else {
  160|     80|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     80|         }
  162|  2.95k|         (void)m( result );
  163|  2.95k|         return result;
  164|  2.95k|      }
  165|  2.95k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.95k|      {
   73|  2.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  2.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.95k|      {
   44|  2.95k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.95k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|  2.89k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.89k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.62k|   {
  104|  6.62k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.62k|         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.62k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.62k|      {
   44|  6.62k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.62k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.87k|      else {
  108|  2.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.72k, False: 141]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.72k|            else if constexpr( has_apply0_bool ) {
  153|  2.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.72k|            }
  155|  2.72k|         }
  156|  2.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.72k, False: 141]
  ------------------
  157|  2.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.72k|         }
  159|    141|         else {
  160|    141|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    141|         }
  162|  2.87k|         (void)m( result );
  163|  2.87k|         return result;
  164|  2.87k|      }
  165|  2.87k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.87k|      {
   73|  2.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|  2.87k|         else {
   84|  2.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.87k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.87k|      {
   59|  2.87k|         return Rule::match( in );
   60|  2.87k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.82k|      else {
  108|  8.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.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|  8.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.82k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.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|  8.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|  8.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|  8.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.82k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.42k, False: 1.40k]
  ------------------
  143|  7.42k|            if constexpr( has_apply_void ) {
  144|  7.42k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.42k|         }
  156|  8.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.34k, False: 1.47k]
  ------------------
  157|  7.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.34k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  8.82k|         (void)m( result );
  163|  8.82k|         return result;
  164|  8.82k|      }
  165|  8.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.82k|      {
   73|  8.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|  8.82k|         else {
   84|  8.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.82k|      {
   44|  8.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.82k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.82k|      else {
  108|  8.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.72k, 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|  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.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.72k, False: 1.10k]
  ------------------
  157|  7.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.72k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|  8.82k|         (void)m( result );
  163|  8.82k|         return result;
  164|  8.82k|      }
  165|  8.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.82k|      {
   73|  8.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|  8.82k|         else {
   84|  8.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.82k|      {
   59|  8.82k|         return Rule::match( in );
   60|  8.82k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.72k|   {
  104|  7.72k|      if constexpr( !Control< Rule >::enable ) {
  105|  7.72k|         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.72k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.72k|      {
   44|  7.72k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.72k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  7.72k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.72k|      else {
  108|  7.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.42k, False: 304]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.42k|            else if constexpr( has_apply0_bool ) {
  153|  7.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.42k|            }
  155|  7.42k|         }
  156|  7.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.42k, False: 304]
  ------------------
  157|  7.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.42k|         }
  159|    304|         else {
  160|    304|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    304|         }
  162|  7.72k|         (void)m( result );
  163|  7.72k|         return result;
  164|  7.72k|      }
  165|  7.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  7.72k|      {
   73|  7.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|  7.72k|         else {
   84|  7.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.72k|      {
   44|  7.72k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.72k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  12.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.0M|      else {
  108|  12.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.42k, False: 12.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|  7.42k|            else if constexpr( has_apply0_bool ) {
  153|  7.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.42k|            }
  155|  7.42k|         }
  156|  12.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.42k, False: 12.0M]
  ------------------
  157|  7.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.42k|         }
  159|  12.0M|         else {
  160|  12.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.0M|         }
  162|  12.0M|         (void)m( result );
  163|  12.0M|         return result;
  164|  12.0M|      }
  165|  12.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  12.0M|      {
   73|  12.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|  12.0M|         else {
   84|  12.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.0M|      }
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|  12.0M|      {
   59|  12.0M|         return Rule::match( in );
   60|  12.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  12.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.0M|      else {
  108|  12.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.0M, False: 304]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  12.0M|            else if constexpr( has_apply0_bool ) {
  153|  12.0M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.0M|            }
  155|  12.0M|         }
  156|  12.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.0M, False: 304]
  ------------------
  157|  12.0M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.0M|         }
  159|    304|         else {
  160|    304|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    304|         }
  162|  12.0M|         (void)m( result );
  163|  12.0M|         return result;
  164|  12.0M|      }
  165|  12.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  12.0M|      {
   73|  12.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|  12.0M|         else {
   84|  12.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.0M|      }
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|  12.0M|      {
   44|  12.0M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  12.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  12.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.0M|      else {
  108|  12.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 176k, False: 11.9M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   176k|            else if constexpr( has_apply0_bool ) {
  153|   176k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   176k|            }
  155|   176k|         }
  156|  12.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 176k, False: 11.9M]
  ------------------
  157|   176k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   176k|         }
  159|  11.9M|         else {
  160|  11.9M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.9M|         }
  162|  12.0M|         (void)m( result );
  163|  12.0M|         return result;
  164|  12.0M|      }
  165|  12.0M|   }
_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|  12.0M|      {
   73|  12.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|  12.0M|         else {
   84|  12.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.0M|      }
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|  12.0M|      {
   44|  12.0M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  12.0M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  12.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.0M|      else {
  108|  12.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 176k, False: 11.9M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   176k|            else if constexpr( has_apply0_bool ) {
  153|   176k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   176k|            }
  155|   176k|         }
  156|  12.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 176k, False: 11.9M]
  ------------------
  157|   176k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   176k|         }
  159|  11.9M|         else {
  160|  11.9M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.9M|         }
  162|  12.0M|         (void)m( result );
  163|  12.0M|         return result;
  164|  12.0M|      }
  165|  12.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  12.0M|      {
   73|  12.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|  12.0M|         else {
   84|  12.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.0M|      }
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|  12.0M|      {
   59|  12.0M|         return Rule::match( in );
   60|  12.0M|      }
_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|   176k|   {
  104|   176k|      if constexpr( !Control< Rule >::enable ) {
  105|   176k|         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|   176k|   }
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|   176k|      {
   44|   176k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   176k|      }
_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|   176k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   176k|      else {
  108|   176k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   176k|         using iterator_t = typename ParseInput::iterator_t;
  111|   176k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   176k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   176k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   176k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   176k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   176k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   176k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   176k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   176k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   176k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   176k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   176k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   176k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   176k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   176k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   176k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   176k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   176k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 176k, False: 102]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   176k|            else if constexpr( has_apply0_bool ) {
  153|   176k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   176k|            }
  155|   176k|         }
  156|   176k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 176k, False: 102]
  ------------------
  157|   176k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   176k|         }
  159|    102|         else {
  160|    102|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    102|         }
  162|   176k|         (void)m( result );
  163|   176k|         return result;
  164|   176k|      }
  165|   176k|   }
_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|   176k|      {
   73|   176k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   176k|         else {
   84|   176k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   176k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   176k|      }
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|   176k|      {
   44|   176k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   176k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   176k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   176k|      else {
  108|   176k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   176k|         using iterator_t = typename ParseInput::iterator_t;
  111|   176k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   176k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   176k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   176k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   176k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   176k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   176k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   176k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   176k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   176k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   176k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   176k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   176k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   176k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   176k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   176k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   176k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   176k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 52.0k, False: 124k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  52.0k|            else if constexpr( has_apply0_bool ) {
  153|  52.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  52.0k|            }
  155|  52.0k|         }
  156|   176k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 52.0k, False: 124k]
  ------------------
  157|  52.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  52.0k|         }
  159|   124k|         else {
  160|   124k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   124k|         }
  162|   176k|         (void)m( result );
  163|   176k|         return result;
  164|   176k|      }
  165|   176k|   }
_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|   176k|      {
   73|   176k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   176k|         else {
   84|   176k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   176k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   176k|      }
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|   176k|      {
   44|   176k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   176k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   176k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   176k|      else {
  108|   176k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   176k|         using iterator_t = typename ParseInput::iterator_t;
  111|   176k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   176k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   176k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   176k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   176k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   176k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   176k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   176k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   176k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   176k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   176k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   176k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   176k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   176k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   176k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   176k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   176k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   176k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 52.0k, False: 124k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  52.0k|            else if constexpr( has_apply0_bool ) {
  153|  52.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  52.0k|            }
  155|  52.0k|         }
  156|   176k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 52.0k, False: 124k]
  ------------------
  157|  52.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  52.0k|         }
  159|   124k|         else {
  160|   124k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   124k|         }
  162|   176k|         (void)m( result );
  163|   176k|         return result;
  164|   176k|      }
  165|   176k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   176k|      {
   73|   176k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   176k|         else {
   84|   176k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   176k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   176k|      }
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|   176k|      {
   59|   176k|         return Rule::match( in );
   60|   176k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  52.0k|   {
  104|  52.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  52.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|  52.0k|   }
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|  52.0k|      {
   44|  52.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  52.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  52.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  52.0k|      else {
  108|  52.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  52.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  52.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|  52.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|  52.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|  52.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|  52.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|  52.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|  52.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  52.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  52.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  52.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|  52.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  52.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  52.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|  52.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  52.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  52.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  52.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  52.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 52.0k, 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|  52.0k|            else if constexpr( has_apply0_bool ) {
  153|  52.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  52.0k|            }
  155|  52.0k|         }
  156|  52.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 52.0k, False: 45]
  ------------------
  157|  52.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  52.0k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  52.0k|         (void)m( result );
  163|  52.0k|         return result;
  164|  52.0k|      }
  165|  52.0k|   }
_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|  52.0k|      {
   73|  52.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|  52.0k|         else {
   84|  52.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  52.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  52.0k|      }
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|  52.0k|      {
   44|  52.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  52.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   104k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   104k|      else {
  108|   104k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   104k|         using iterator_t = typename ParseInput::iterator_t;
  111|   104k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   104k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   104k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   104k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   104k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   104k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   104k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   104k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   104k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   104k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   104k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   104k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   104k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   104k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   104k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   104k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   104k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   104k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 104k, 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|   104k|            else if constexpr( has_apply0_bool ) {
  153|   104k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   104k|            }
  155|   104k|         }
  156|   104k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 104k, False: 45]
  ------------------
  157|   104k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   104k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|   104k|         (void)m( result );
  163|   104k|         return result;
  164|   104k|      }
  165|   104k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   104k|      {
   73|   104k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   104k|         else {
   84|   104k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   104k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   104k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   104k|      {
   59|   104k|         return Rule::match( in );
   60|   104k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   124k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   124k|      else {
  108|   124k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   124k|         using iterator_t = typename ParseInput::iterator_t;
  111|   124k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   124k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   124k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   124k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   124k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   124k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   124k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   124k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   124k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   124k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   124k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   124k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   124k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   124k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   124k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   124k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   124k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   124k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 64.7k, 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|  64.7k|            else if constexpr( has_apply0_bool ) {
  153|  64.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  64.7k|            }
  155|  64.7k|         }
  156|   124k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 64.7k, False: 59.8k]
  ------------------
  157|  64.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  64.7k|         }
  159|  59.8k|         else {
  160|  59.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  59.8k|         }
  162|   124k|         (void)m( result );
  163|   124k|         return result;
  164|   124k|      }
  165|   124k|   }
_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|   124k|      {
   73|   124k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   124k|         else {
   84|   124k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   124k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   124k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_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|   124k|      {
   44|   124k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   124k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   198k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   198k|      else {
  108|   198k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   198k|         using iterator_t = typename ParseInput::iterator_t;
  111|   198k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   198k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   198k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   198k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   198k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   198k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   198k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   198k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   198k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   198k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   198k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   198k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   198k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   198k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   198k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   198k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   198k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   198k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 80.0k, False: 118k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  80.0k|            else if constexpr( has_apply0_bool ) {
  153|  80.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  80.0k|            }
  155|  80.0k|         }
  156|   198k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 80.0k, False: 118k]
  ------------------
  157|  80.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  80.0k|         }
  159|   118k|         else {
  160|   118k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   118k|         }
  162|   198k|         (void)m( result );
  163|   198k|         return result;
  164|   198k|      }
  165|   198k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   198k|      {
   73|   198k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   198k|         else {
   84|   198k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   198k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   198k|      }
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|   198k|      {
   59|   198k|         return Rule::match( in );
   60|   198k|      }
_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|  64.7k|   {
  104|  64.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  64.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|  64.7k|   }
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|  64.7k|      {
   44|  64.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  64.7k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  64.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  64.7k|      else {
  108|  64.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  64.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  64.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|  64.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|  64.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|  64.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|  64.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|  64.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|  64.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  64.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  64.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  64.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|  64.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  64.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  64.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|  64.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  64.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  64.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  64.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  64.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 64.7k, 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|  64.7k|            else if constexpr( has_apply0_bool ) {
  153|  64.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  64.7k|            }
  155|  64.7k|         }
  156|  64.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 64.7k, False: 0]
  ------------------
  157|  64.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  64.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  64.7k|         (void)m( result );
  163|  64.7k|         return result;
  164|  64.7k|      }
  165|  64.7k|   }
_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|  64.7k|      {
   73|  64.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|  64.7k|         else {
   84|  64.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  64.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  64.7k|      }
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|  64.7k|      {
   44|  64.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  64.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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: 58.6k, False: 1.22k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  58.6k|            else if constexpr( has_apply0_bool ) {
  153|  58.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  58.6k|            }
  155|  58.6k|         }
  156|  59.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 58.6k, False: 1.22k]
  ------------------
  157|  58.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  58.6k|         }
  159|  1.22k|         else {
  160|  1.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.22k|         }
  162|  59.8k|         (void)m( result );
  163|  59.8k|         return result;
  164|  59.8k|      }
  165|  59.8k|   }
_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|  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_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|  59.8k|      {
   59|  59.8k|         return Rule::match( in );
   60|  59.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.22k|      else {
  108|  1.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.22k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.16k, False: 57]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.16k|            else if constexpr( has_apply0_bool ) {
  153|  1.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.16k|            }
  155|  1.16k|         }
  156|  1.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.16k, False: 57]
  ------------------
  157|  1.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.16k|         }
  159|     57|         else {
  160|     57|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     57|         }
  162|  1.22k|         (void)m( result );
  163|  1.22k|         return result;
  164|  1.22k|      }
  165|  1.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.22k|      {
   73|  1.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.22k|         else {
   84|  1.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.22k|      }
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|  1.22k|      {
   59|  1.22k|         return Rule::match( in );
   60|  1.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.9M|      else {
  108|  11.9M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9M|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9M|         constexpr bool has_apply_void = enable_action && internal::has_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.9M|         constexpr bool has_apply_bool = enable_action && internal::has_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.9M|         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.9M|         constexpr bool has_apply0_void = enable_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.9M|         constexpr bool has_apply0_bool = enable_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.9M|         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.9M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.9M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.9M, False: 202]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9M|            else if constexpr( has_apply0_bool ) {
  153|  11.9M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.9M|            }
  155|  11.9M|         }
  156|  11.9M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.9M, False: 202]
  ------------------
  157|  11.9M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.9M|         }
  159|    202|         else {
  160|    202|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    202|         }
  162|  11.9M|         (void)m( result );
  163|  11.9M|         return result;
  164|  11.9M|      }
  165|  11.9M|   }
_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|  11.9M|      {
   73|  11.9M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.9M|         else {
   84|  11.9M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9M|      }
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|  11.9M|      {
   59|  11.9M|         return Rule::match( in );
   60|  11.9M|      }
_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|  34.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.0k|      else {
  108|  34.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 31.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  34.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 31.5k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  31.5k|         else {
  160|  31.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.5k|         }
  162|  34.0k|         (void)m( result );
  163|  34.0k|         return result;
  164|  34.0k|      }
  165|  34.0k|   }
_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|  34.0k|      {
   73|  34.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|  34.0k|         else {
   84|  34.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.0k|      }
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|  34.0k|      {
   44|  34.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.0k|      }
_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|  34.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.0k|      else {
  108|  34.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 31.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.49k|            else if constexpr( has_apply0_bool ) {
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  34.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 31.5k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  31.5k|         else {
  160|  31.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.5k|         }
  162|  34.0k|         (void)m( result );
  163|  34.0k|         return result;
  164|  34.0k|      }
  165|  34.0k|   }
_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|  34.0k|      {
   73|  34.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|  34.0k|         else {
   84|  34.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.0k|      }
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|  34.0k|      {
   44|  34.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.0k|      }
_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|  34.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.0k|      else {
  108|  34.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 34.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  34.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|  34.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|  34.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|  34.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 34.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.14k, False: 30.8k]
  ------------------
  143|  3.14k|            if constexpr( has_apply_void ) {
  144|  3.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|  3.14k|         }
  156|  34.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.14k, False: 30.8k]
  ------------------
  157|  3.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.14k|         }
  159|  30.8k|         else {
  160|  30.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.8k|         }
  162|  34.0k|         (void)m( result );
  163|  34.0k|         return result;
  164|  34.0k|      }
  165|  34.0k|   }
_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|  34.0k|      {
   73|  34.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|  34.0k|         else {
   84|  34.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.0k|      }
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|  34.0k|      {
   59|  34.0k|         return Rule::match( in );
   60|  34.0k|      }
_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.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.89k|      else {
  108|  8.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.47k, False: 1.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.47k|            else if constexpr( has_apply0_bool ) {
  153|  7.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.47k|            }
  155|  7.47k|         }
  156|  8.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.47k, False: 1.41k]
  ------------------
  157|  7.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.47k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  8.89k|         (void)m( result );
  163|  8.89k|         return result;
  164|  8.89k|      }
  165|  8.89k|   }
_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.89k|      {
   73|  8.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|  8.89k|         else {
   84|  8.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.89k|      }
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.89k|      {
   44|  8.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.89k|      else {
  108|  8.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.47k, False: 1.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.47k|            else if constexpr( has_apply0_bool ) {
  153|  7.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.47k|            }
  155|  7.47k|         }
  156|  8.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.47k, False: 1.41k]
  ------------------
  157|  7.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.47k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  8.89k|         (void)m( result );
  163|  8.89k|         return result;
  164|  8.89k|      }
  165|  8.89k|   }
_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.89k|      {
   73|  8.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|  8.89k|         else {
   84|  8.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.89k|      }
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.89k|      {
   59|  8.89k|         return Rule::match( in );
   60|  8.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_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: 4.41k, False: 11.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|  4.41k|            else if constexpr( has_apply0_bool ) {
  153|  4.41k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.41k|            }
  155|  4.41k|         }
  156|  15.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.41k, False: 11.4k]
  ------------------
  157|  4.41k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.41k|         }
  159|  11.4k|         else {
  160|  11.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.4k|         }
  162|  15.8k|         (void)m( result );
  163|  15.8k|         return result;
  164|  15.8k|      }
  165|  15.8k|   }
_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|  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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_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_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 636]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.49k|            else if constexpr( has_apply0_bool ) {
  153|  2.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49k|            }
  155|  2.49k|         }
  156|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 636]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|    636|         else {
  160|    636|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    636|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.12k|      {
   44|  3.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.83k, False: 1.29k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.83k|            else if constexpr( has_apply0_bool ) {
  153|  1.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.83k|            }
  155|  1.83k|         }
  156|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.83k, False: 1.29k]
  ------------------
  157|  1.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.83k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.12k|      {
   44|  3.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.12k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.12k, 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.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.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.12k, False: 0]
  ------------------
  157|  3.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.12k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.12k|      {
   44|  3.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.12k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|  3.12k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.12k|         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.12k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.12k|      {
   44|  3.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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): [True: 0, Folded]
  ------------------
  112|  3.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|  3.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.12k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.12k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.03k, False: 2.09k]
  ------------------
  143|  1.03k|            if constexpr( has_apply_void ) {
  144|  1.03k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.03k|         }
  156|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.03k, False: 2.09k]
  ------------------
  157|  1.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.03k|         }
  159|  2.09k|         else {
  160|  2.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.09k|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.12k|      {
   44|  3.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 213, 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|    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|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 213, False: 2.91k]
  ------------------
  157|    213|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    213|         }
  159|  2.91k|         else {
  160|  2.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.91k|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.12k|      {
   59|  3.12k|         return Rule::match( in );
   60|  3.12k|      }
_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.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.91k|      else {
  108|  2.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 237, False: 2.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 237, False: 2.67k]
  ------------------
  157|    237|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    237|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  2.91k|         (void)m( result );
  163|  2.91k|         return result;
  164|  2.91k|      }
  165|  2.91k|   }
_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.91k|      {
   73|  2.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|  2.91k|         else {
   84|  2.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.91k|      {
   59|  2.91k|         return Rule::match( in );
   60|  2.91k|      }
_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.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.67k|      else {
  108|  2.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 67, False: 2.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     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|  2.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 67, False: 2.61k]
  ------------------
  157|     67|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     67|         }
  159|  2.61k|         else {
  160|  2.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.61k|         }
  162|  2.67k|         (void)m( result );
  163|  2.67k|         return result;
  164|  2.67k|      }
  165|  2.67k|   }
_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.67k|      {
   73|  2.67k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.67k|         else {
   84|  2.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.67k|      {
   59|  2.67k|         return Rule::match( in );
   60|  2.67k|      }
_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.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.61k|      else {
  108|  2.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.61k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.41k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.41k|         else {
  160|  2.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.41k|         }
  162|  2.61k|         (void)m( result );
  163|  2.61k|         return result;
  164|  2.61k|      }
  165|  2.61k|   }
_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.61k|      {
   73|  2.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.61k|         else {
   84|  2.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.61k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.61k|      {
   59|  2.61k|         return Rule::match( in );
   60|  2.61k|      }
_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.41k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.41k|      else {
  108|  2.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.41k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 251, False: 2.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|    251|            else if constexpr( has_apply0_bool ) {
  153|    251|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    251|            }
  155|    251|         }
  156|  2.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 251, False: 2.16k]
  ------------------
  157|    251|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    251|         }
  159|  2.16k|         else {
  160|  2.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.16k|         }
  162|  2.41k|         (void)m( result );
  163|  2.41k|         return result;
  164|  2.41k|      }
  165|  2.41k|   }
_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.41k|      {
   73|  2.41k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.41k|         else {
   84|  2.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.41k|      }
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.41k|      {
   59|  2.41k|         return Rule::match( in );
   60|  2.41k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.16k|      else {
  108|  2.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 71, False: 2.09k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     71|            else if constexpr( has_apply0_bool ) {
  153|     71|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     71|            }
  155|     71|         }
  156|  2.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 71, False: 2.09k]
  ------------------
  157|     71|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     71|         }
  159|  2.09k|         else {
  160|  2.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.09k|         }
  162|  2.16k|         (void)m( result );
  163|  2.16k|         return result;
  164|  2.16k|      }
  165|  2.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.16k|      {
   73|  2.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|  2.16k|         else {
   84|  2.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.16k|      {
   59|  2.16k|         return Rule::match( in );
   60|  2.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.03k, False: 1.09k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.03k|            else if constexpr( has_apply0_bool ) {
  153|  2.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.03k|            }
  155|  2.03k|         }
  156|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.03k, False: 1.09k]
  ------------------
  157|  2.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.03k|         }
  159|  1.09k|         else {
  160|  1.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.09k|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.12k|      {
   73|  3.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|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.12k|      {
   59|  3.12k|         return Rule::match( in );
   60|  3.12k|      }
_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.98k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.98k|      else {
  108|  3.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.98k, 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.98k|            else if constexpr( has_apply0_bool ) {
  153|  3.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.98k|            }
  155|  3.98k|         }
  156|  3.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.98k, False: 0]
  ------------------
  157|  3.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.98k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.98k|         (void)m( result );
  163|  3.98k|         return result;
  164|  3.98k|      }
  165|  3.98k|   }
_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.98k|      {
   73|  3.98k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.98k|         else {
   84|  3.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.98k|      }
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.98k|      {
   44|  3.98k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.98k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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: 1.95k, 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|  1.95k|            else if constexpr( has_apply0_bool ) {
  153|  1.95k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.95k|            }
  155|  1.95k|         }
  156|  2.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.95k, False: 81]
  ------------------
  157|  1.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.95k|         }
  159|     81|         else {
  160|     81|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     81|         }
  162|  2.03k|         (void)m( result );
  163|  2.03k|         return result;
  164|  2.03k|      }
  165|  2.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.03k|      {
   44|  2.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.03k|      }
_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.96k|   {
  104|  1.96k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.96k|         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.96k|   }
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.96k|      {
   44|  1.96k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.96k|      }
_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.71k|   {
  104|  4.71k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.71k|   }
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.71k|      {
   44|  4.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.95k|      else {
  108|  1.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.95k|         constexpr bool has_apply_void = enable_action && internal::has_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.95k|         constexpr bool has_apply_bool = enable_action && internal::has_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.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.83k, False: 119]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.83k|            else if constexpr( has_apply0_bool ) {
  153|  1.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.83k|            }
  155|  1.83k|         }
  156|  1.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.83k, False: 119]
  ------------------
  157|  1.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.83k|         }
  159|    119|         else {
  160|    119|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    119|         }
  162|  1.95k|         (void)m( result );
  163|  1.95k|         return result;
  164|  1.95k|      }
  165|  1.95k|   }
_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.95k|      {
   73|  1.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  1.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.95k|      }
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.95k|      {
   59|  1.95k|         return Rule::match( in );
   60|  1.95k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.65k|      else {
  108|  6.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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): [True: 0, Folded]
  ------------------
  112|  6.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|  6.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.65k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.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|  6.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|  6.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|  6.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.65k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.43k, False: 1.21k]
  ------------------
  143|  5.43k|            if constexpr( has_apply_void ) {
  144|  5.43k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43k|         }
  156|  6.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 1.27k]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|  1.27k|         else {
  160|  1.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.27k|         }
  162|  6.65k|         (void)m( result );
  163|  6.65k|         return result;
  164|  6.65k|      }
  165|  6.65k|   }
_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|  6.65k|      {
   73|  6.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|  6.65k|         else {
   84|  6.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.65k|      }
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|  6.65k|      {
   44|  6.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.65k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.65k|      else {
  108|  6.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.69k, False: 955]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.69k|            else if constexpr( has_apply0_bool ) {
  153|  5.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.69k|            }
  155|  5.69k|         }
  156|  6.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.69k, False: 955]
  ------------------
  157|  5.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.69k|         }
  159|    955|         else {
  160|    955|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    955|         }
  162|  6.65k|         (void)m( result );
  163|  6.65k|         return result;
  164|  6.65k|      }
  165|  6.65k|   }
_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|  6.65k|      {
   73|  6.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|  6.65k|         else {
   84|  6.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.65k|      }
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|  6.65k|      {
   59|  6.65k|         return Rule::match( in );
   60|  6.65k|      }
_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.69k|   {
  104|  5.69k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.69k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.69k|   }
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.69k|      {
   44|  5.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.69k|      }
_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.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: 5.43k, False: 261]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43k|            else if constexpr( has_apply0_bool ) {
  153|  5.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.43k|            }
  155|  5.43k|         }
  156|  5.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.43k, False: 261]
  ------------------
  157|  5.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.43k|         }
  159|    261|         else {
  160|    261|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    261|         }
  162|  5.69k|         (void)m( result );
  163|  5.69k|         return result;
  164|  5.69k|      }
  165|  5.69k|   }
_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.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_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.69k|      {
   44|  5.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.69k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.96M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.96M|      else {
  108|  9.96M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.96M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.96M|         constexpr bool has_apply_void = enable_action && internal::has_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.96M|         constexpr bool has_apply_bool = enable_action && internal::has_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.96M|         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.96M|         constexpr bool has_apply0_void = enable_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.96M|         constexpr bool has_apply0_bool = enable_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.96M|         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.96M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.96M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.96M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.96M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.96M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.96M|         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.96M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.96M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.96M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.96M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.96M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.43k, False: 9.96M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43k|            else if constexpr( has_apply0_bool ) {
  153|  5.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.43k|            }
  155|  5.43k|         }
  156|  9.96M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.43k, False: 9.96M]
  ------------------
  157|  5.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.43k|         }
  159|  9.96M|         else {
  160|  9.96M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.96M|         }
  162|  9.96M|         (void)m( result );
  163|  9.96M|         return result;
  164|  9.96M|      }
  165|  9.96M|   }
_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|  9.96M|      {
   73|  9.96M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96M|         else {
   84|  9.96M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.96M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.96M|      }
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|  9.96M|      {
   59|  9.96M|         return Rule::match( in );
   60|  9.96M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.96M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.96M|      else {
  108|  9.96M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.96M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.96M|         constexpr bool has_apply_void = enable_action && internal::has_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.96M|         constexpr bool has_apply_bool = enable_action && internal::has_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.96M|         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.96M|         constexpr bool has_apply0_void = enable_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.96M|         constexpr bool has_apply0_bool = enable_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.96M|         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.96M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.96M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.96M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.96M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.96M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.96M|         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.96M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.96M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.96M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.96M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.96M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.96M, False: 261]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.96M|            else if constexpr( has_apply0_bool ) {
  153|  9.96M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.96M|            }
  155|  9.96M|         }
  156|  9.96M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.96M, False: 261]
  ------------------
  157|  9.96M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.96M|         }
  159|    261|         else {
  160|    261|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    261|         }
  162|  9.96M|         (void)m( result );
  163|  9.96M|         return result;
  164|  9.96M|      }
  165|  9.96M|   }
_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|  9.96M|      {
   73|  9.96M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96M|         else {
   84|  9.96M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.96M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.96M|      }
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|  9.96M|      {
   44|  9.96M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.96M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.96M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.96M|      else {
  108|  9.96M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.96M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.96M|         constexpr bool has_apply_void = enable_action && internal::has_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.96M|         constexpr bool has_apply_bool = enable_action && internal::has_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.96M|         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.96M|         constexpr bool has_apply0_void = enable_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.96M|         constexpr bool has_apply0_bool = enable_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.96M|         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.96M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.96M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.96M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.96M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.96M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.96M|         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.96M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.96M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.96M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.96M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.96M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 131k, False: 9.83M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   131k|            else if constexpr( has_apply0_bool ) {
  153|   131k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   131k|            }
  155|   131k|         }
  156|  9.96M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 131k, False: 9.83M]
  ------------------
  157|   131k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   131k|         }
  159|  9.83M|         else {
  160|  9.83M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.83M|         }
  162|  9.96M|         (void)m( result );
  163|  9.96M|         return result;
  164|  9.96M|      }
  165|  9.96M|   }
_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|  9.96M|      {
   73|  9.96M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96M|         else {
   84|  9.96M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.96M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.96M|      }
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|  9.96M|      {
   44|  9.96M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.96M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.96M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.96M|      else {
  108|  9.96M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.96M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.96M|         constexpr bool has_apply_void = enable_action && internal::has_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.96M|         constexpr bool has_apply_bool = enable_action && internal::has_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.96M|         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.96M|         constexpr bool has_apply0_void = enable_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.96M|         constexpr bool has_apply0_bool = enable_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.96M|         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.96M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.96M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.96M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.96M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.96M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.96M|         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.96M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.96M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.96M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.96M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.96M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 131k, False: 9.83M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   131k|            else if constexpr( has_apply0_bool ) {
  153|   131k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   131k|            }
  155|   131k|         }
  156|  9.96M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 131k, False: 9.83M]
  ------------------
  157|   131k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   131k|         }
  159|  9.83M|         else {
  160|  9.83M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.83M|         }
  162|  9.96M|         (void)m( result );
  163|  9.96M|         return result;
  164|  9.96M|      }
  165|  9.96M|   }
_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|  9.96M|      {
   73|  9.96M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96M|         else {
   84|  9.96M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.96M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.96M|      }
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|  9.96M|      {
   59|  9.96M|         return Rule::match( in );
   60|  9.96M|      }
_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|   131k|   {
  104|   131k|      if constexpr( !Control< Rule >::enable ) {
  105|   131k|         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|   131k|   }
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|   131k|      {
   44|   131k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   131k|      }
_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|   131k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   131k|      else {
  108|   131k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   131k|         using iterator_t = typename ParseInput::iterator_t;
  111|   131k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   131k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   131k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   131k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   131k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   131k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   131k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   131k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   131k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   131k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   131k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   131k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   131k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   131k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   131k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   131k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   131k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   131k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 131k, False: 84]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   131k|            else if constexpr( has_apply0_bool ) {
  153|   131k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   131k|            }
  155|   131k|         }
  156|   131k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 131k, False: 84]
  ------------------
  157|   131k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   131k|         }
  159|     84|         else {
  160|     84|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     84|         }
  162|   131k|         (void)m( result );
  163|   131k|         return result;
  164|   131k|      }
  165|   131k|   }
_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|   131k|      {
   73|   131k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   131k|         else {
   84|   131k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   131k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   131k|      }
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|   131k|      {
   44|   131k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   131k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   131k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   131k|      else {
  108|   131k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   131k|         using iterator_t = typename ParseInput::iterator_t;
  111|   131k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   131k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   131k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   131k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   131k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   131k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   131k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   131k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   131k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   131k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   131k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   131k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   131k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   131k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   131k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   131k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   131k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   131k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.9k, False: 86.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|  44.9k|            else if constexpr( has_apply0_bool ) {
  153|  44.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.9k|            }
  155|  44.9k|         }
  156|   131k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.9k, False: 86.4k]
  ------------------
  157|  44.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.9k|         }
  159|  86.4k|         else {
  160|  86.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.4k|         }
  162|   131k|         (void)m( result );
  163|   131k|         return result;
  164|   131k|      }
  165|   131k|   }
_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|   131k|      {
   73|   131k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   131k|         else {
   84|   131k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   131k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   131k|      }
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|   131k|      {
   44|   131k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   131k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   131k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   131k|      else {
  108|   131k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   131k|         using iterator_t = typename ParseInput::iterator_t;
  111|   131k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   131k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   131k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   131k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   131k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   131k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   131k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   131k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   131k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   131k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   131k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   131k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   131k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   131k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   131k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   131k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   131k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   131k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.0k, False: 86.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|  45.0k|            else if constexpr( has_apply0_bool ) {
  153|  45.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.0k|            }
  155|  45.0k|         }
  156|   131k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.0k, False: 86.4k]
  ------------------
  157|  45.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.0k|         }
  159|  86.4k|         else {
  160|  86.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.4k|         }
  162|   131k|         (void)m( result );
  163|   131k|         return result;
  164|   131k|      }
  165|   131k|   }
_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|   131k|      {
   73|   131k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   131k|         else {
   84|   131k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   131k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   131k|      }
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|   131k|      {
   59|   131k|         return Rule::match( in );
   60|   131k|      }
_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|  45.0k|   {
  104|  45.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  45.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|  45.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|  45.0k|      {
   44|  45.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.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|  45.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.0k|      else {
  108|  45.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  45.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  45.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|  45.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|  45.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|  45.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|  45.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  45.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.9k, False: 32]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.9k|            else if constexpr( has_apply0_bool ) {
  153|  44.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.9k|            }
  155|  44.9k|         }
  156|  45.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.9k, False: 32]
  ------------------
  157|  44.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.9k|         }
  159|     32|         else {
  160|     32|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     32|         }
  162|  45.0k|         (void)m( result );
  163|  45.0k|         return result;
  164|  45.0k|      }
  165|  45.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|  45.0k|      {
   73|  45.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|  45.0k|         else {
   84|  45.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  45.0k|      {
   44|  45.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  89.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  89.9k|      else {
  108|  89.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  89.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  89.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|  89.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|  89.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|  89.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|  89.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|  89.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|  89.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  89.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  89.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  89.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|  89.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  89.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  89.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|  89.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  89.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  89.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  89.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  89.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 89.9k, False: 32]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  89.9k|            else if constexpr( has_apply0_bool ) {
  153|  89.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  89.9k|            }
  155|  89.9k|         }
  156|  89.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 89.9k, False: 32]
  ------------------
  157|  89.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  89.9k|         }
  159|     32|         else {
  160|     32|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     32|         }
  162|  89.9k|         (void)m( result );
  163|  89.9k|         return result;
  164|  89.9k|      }
  165|  89.9k|   }
_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|  89.9k|      {
   73|  89.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|  89.9k|         else {
   84|  89.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  89.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  89.9k|      }
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|  89.9k|      {
   59|  89.9k|         return Rule::match( in );
   60|  89.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  86.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  86.4k|      else {
  108|  86.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.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|  86.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|  86.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|  86.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|  86.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|  86.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|  86.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.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|  86.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.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|  86.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  86.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.4k, False: 59.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|  27.4k|            else if constexpr( has_apply0_bool ) {
  153|  27.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.4k|            }
  155|  27.4k|         }
  156|  86.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.4k, False: 59.0k]
  ------------------
  157|  27.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.4k|         }
  159|  59.0k|         else {
  160|  59.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  59.0k|         }
  162|  86.4k|         (void)m( result );
  163|  86.4k|         return result;
  164|  86.4k|      }
  165|  86.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|  86.4k|      {
   73|  86.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|  86.4k|         else {
   84|  86.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.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|  86.4k|      {
   44|  86.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   128k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   128k|      else {
  108|   128k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   128k|         using iterator_t = typename ParseInput::iterator_t;
  111|   128k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   128k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   128k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   128k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   128k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   128k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   128k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   128k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   128k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   128k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   128k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   128k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   128k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   128k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   128k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   128k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   128k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   128k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 54.8k, False: 74.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|  54.8k|            else if constexpr( has_apply0_bool ) {
  153|  54.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  54.8k|            }
  155|  54.8k|         }
  156|   128k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 54.8k, False: 74.1k]
  ------------------
  157|  54.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  54.8k|         }
  159|  74.1k|         else {
  160|  74.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  74.1k|         }
  162|   128k|         (void)m( result );
  163|   128k|         return result;
  164|   128k|      }
  165|   128k|   }
_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|   128k|      {
   73|   128k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   128k|         else {
   84|   128k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   128k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   128k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   128k|      {
   59|   128k|         return Rule::match( in );
   60|   128k|      }
_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|  27.4k|   {
  104|  27.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  27.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|  27.4k|   }
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|  27.4k|      {
   44|  27.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.4k|      }
_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|  27.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.4k|      else {
  108|  27.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  27.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  27.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|  27.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|  27.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|  27.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|  27.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  27.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.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|  27.4k|            else if constexpr( has_apply0_bool ) {
  153|  27.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.4k|            }
  155|  27.4k|         }
  156|  27.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.4k, False: 0]
  ------------------
  157|  27.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  27.4k|         (void)m( result );
  163|  27.4k|         return result;
  164|  27.4k|      }
  165|  27.4k|   }
_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|  27.4k|      {
   73|  27.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|  27.4k|         else {
   84|  27.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  27.4k|      {
   44|  27.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  59.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  59.0k|      else {
  108|  59.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  59.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  59.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|  59.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|  59.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|  59.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|  59.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|  59.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|  59.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  59.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  59.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  59.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|  59.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  59.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  59.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|  59.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  59.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  59.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  59.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  59.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 58.1k, False: 831]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  58.1k|            else if constexpr( has_apply0_bool ) {
  153|  58.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  58.1k|            }
  155|  58.1k|         }
  156|  59.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 58.1k, False: 831]
  ------------------
  157|  58.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  58.1k|         }
  159|    831|         else {
  160|    831|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    831|         }
  162|  59.0k|         (void)m( result );
  163|  59.0k|         return result;
  164|  59.0k|      }
  165|  59.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  59.0k|      {
   73|  59.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|  59.0k|         else {
   84|  59.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  59.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  59.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  59.0k|      {
   59|  59.0k|         return Rule::match( in );
   60|  59.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    831|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    831|      else {
  108|    831|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    831|         using iterator_t = typename ParseInput::iterator_t;
  111|    831|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    831|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    831|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    831|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    831|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    831|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    831|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    831|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    831|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    831|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    831|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    831|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    831|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    831|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    831|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    831|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    831|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    831|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 779, 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|    779|            else if constexpr( has_apply0_bool ) {
  153|    779|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    779|            }
  155|    779|         }
  156|    831|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 779, False: 52]
  ------------------
  157|    779|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    779|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|    831|         (void)m( result );
  163|    831|         return result;
  164|    831|      }
  165|    831|   }
_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|    831|      {
   73|    831|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    831|         else {
   84|    831|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    831|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    831|      }
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|    831|      {
   59|    831|         return Rule::match( in );
   60|    831|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.83M|      else {
  108|  9.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.83M|         constexpr bool has_apply_void = enable_action && internal::has_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.83M|         constexpr bool has_apply_bool = enable_action && internal::has_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.83M|         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.83M|         constexpr bool has_apply0_void = enable_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.83M|         constexpr bool has_apply0_bool = enable_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.83M|         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.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.83M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.83M|         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.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.83M, 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.83M|            else if constexpr( has_apply0_bool ) {
  153|  9.83M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.83M|            }
  155|  9.83M|         }
  156|  9.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.83M, False: 177]
  ------------------
  157|  9.83M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.83M|         }
  159|    177|         else {
  160|    177|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    177|         }
  162|  9.83M|         (void)m( result );
  163|  9.83M|         return result;
  164|  9.83M|      }
  165|  9.83M|   }
_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|  9.83M|      {
   73|  9.83M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.83M|         else {
   84|  9.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.83M|      }
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|  9.83M|      {
   59|  9.83M|         return Rule::match( in );
   60|  9.83M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.2k|      else {
  108|  31.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.72k, False: 28.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.72k|            else if constexpr( has_apply0_bool ) {
  153|  2.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.72k|            }
  155|  2.72k|         }
  156|  31.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.72k, False: 28.4k]
  ------------------
  157|  2.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.72k|         }
  159|  28.4k|         else {
  160|  28.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.4k|         }
  162|  31.2k|         (void)m( result );
  163|  31.2k|         return result;
  164|  31.2k|      }
  165|  31.2k|   }
_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|  31.2k|      {
   73|  31.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|  31.2k|         else {
   84|  31.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.2k|      }
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|  31.2k|      {
   44|  31.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.2k|      }
_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|  31.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.2k|      else {
  108|  31.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.72k, False: 28.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.72k|            else if constexpr( has_apply0_bool ) {
  153|  2.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.72k|            }
  155|  2.72k|         }
  156|  31.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.72k, False: 28.4k]
  ------------------
  157|  2.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.72k|         }
  159|  28.4k|         else {
  160|  28.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.4k|         }
  162|  31.2k|         (void)m( result );
  163|  31.2k|         return result;
  164|  31.2k|      }
  165|  31.2k|   }
_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|  31.2k|      {
   73|  31.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|  31.2k|         else {
   84|  31.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.2k|      }
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|  31.2k|      {
   44|  31.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.2k|      else {
  108|  31.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  31.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|  31.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 31.2k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.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|  31.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|  31.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|  31.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 31.2k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.20k, False: 28.0k]
  ------------------
  143|  3.20k|            if constexpr( has_apply_void ) {
  144|  3.20k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.20k|         }
  156|  31.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.19k, False: 28.0k]
  ------------------
  157|  3.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.19k|         }
  159|  28.0k|         else {
  160|  28.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.0k|         }
  162|  31.2k|         (void)m( result );
  163|  31.2k|         return result;
  164|  31.2k|      }
  165|  31.2k|   }
_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|  31.2k|      {
   73|  31.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|  31.2k|         else {
   84|  31.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.2k|      }
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|  31.2k|      {
   59|  31.2k|         return Rule::match( in );
   60|  31.2k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.27k|      else {
  108|  8.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.71k, False: 1.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.71k|            else if constexpr( has_apply0_bool ) {
  153|  6.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.71k|            }
  155|  6.71k|         }
  156|  8.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.71k, False: 1.55k]
  ------------------
  157|  6.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.71k|         }
  159|  1.55k|         else {
  160|  1.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.55k|         }
  162|  8.27k|         (void)m( result );
  163|  8.27k|         return result;
  164|  8.27k|      }
  165|  8.27k|   }
_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.27k|      {
   73|  8.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.27k|         else {
   84|  8.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.27k|      }
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.27k|      {
   44|  8.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.27k|      else {
  108|  8.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.71k, False: 1.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.71k|            else if constexpr( has_apply0_bool ) {
  153|  6.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.71k|            }
  155|  6.71k|         }
  156|  8.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.71k, False: 1.55k]
  ------------------
  157|  6.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.71k|         }
  159|  1.55k|         else {
  160|  1.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.55k|         }
  162|  8.27k|         (void)m( result );
  163|  8.27k|         return result;
  164|  8.27k|      }
  165|  8.27k|   }
_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.27k|      {
   73|  8.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.27k|         else {
   84|  8.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.27k|      }
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.27k|      {
   59|  8.27k|         return Rule::match( in );
   60|  8.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.3k|      else {
  108|  15.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.92k, False: 10.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.92k|            else if constexpr( has_apply0_bool ) {
  153|  4.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.92k|            }
  155|  4.92k|         }
  156|  15.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.92k, False: 10.3k]
  ------------------
  157|  4.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.92k|         }
  159|  10.3k|         else {
  160|  10.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.3k|         }
  162|  15.3k|         (void)m( result );
  163|  15.3k|         return result;
  164|  15.3k|      }
  165|  15.3k|   }
_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.3k|      {
   73|  15.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|  15.3k|         else {
   84|  15.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.3k|      }
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.3k|      {
   59|  15.3k|         return Rule::match( in );
   60|  15.3k|      }
_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.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.72k, False: 459]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.72k|            else if constexpr( has_apply0_bool ) {
  153|  2.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.72k|            }
  155|  2.72k|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.72k, False: 459]
  ------------------
  157|  2.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.72k|         }
  159|    459|         else {
  160|    459|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    459|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   44|  3.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.18k|      }
_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.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70k, False: 1.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.70k|            else if constexpr( has_apply0_bool ) {
  153|  1.70k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70k|            }
  155|  1.70k|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70k, False: 1.47k]
  ------------------
  157|  1.70k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   44|  3.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.18k|      }
_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.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.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|  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|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.18k, False: 0]
  ------------------
  157|  3.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.18k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   44|  3.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.18k|      }
_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.18k|   {
  104|  3.18k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.18k|         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.18k|   }
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.18k|      {
   44|  3.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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): [True: 0, Folded]
  ------------------
  112|  3.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|  3.18k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.18k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.18k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.35k, False: 1.82k]
  ------------------
  143|  1.35k|            if constexpr( has_apply_void ) {
  144|  1.35k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.35k|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.35k, False: 1.82k]
  ------------------
  157|  1.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.35k|         }
  159|  1.82k|         else {
  160|  1.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.82k|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   44|  3.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.18k|      }
_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.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 234, False: 2.95k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    234|            else if constexpr( has_apply0_bool ) {
  153|    234|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    234|            }
  155|    234|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 234, False: 2.95k]
  ------------------
  157|    234|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    234|         }
  159|  2.95k|         else {
  160|  2.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.95k|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   59|  3.18k|         return Rule::match( in );
   60|  3.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.95k|      else {
  108|  2.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.95k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.95k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 206, False: 2.74k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    206|            else if constexpr( has_apply0_bool ) {
  153|    206|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    206|            }
  155|    206|         }
  156|  2.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 206, False: 2.74k]
  ------------------
  157|    206|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    206|         }
  159|  2.74k|         else {
  160|  2.74k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.74k|         }
  162|  2.95k|         (void)m( result );
  163|  2.95k|         return result;
  164|  2.95k|      }
  165|  2.95k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.95k|      {
   73|  2.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  2.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.95k|      {
   59|  2.95k|         return Rule::match( in );
   60|  2.95k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.74k|      else {
  108|  2.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.74k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.55k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.55k|         else {
  160|  2.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.55k|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_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.74k|      {
   73|  2.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.74k|         else {
   84|  2.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.74k|      {
   59|  2.74k|         return Rule::match( in );
   60|  2.74k|      }
_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.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.55k|      else {
  108|  2.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.55k|         constexpr bool has_apply_void = enable_action && internal::has_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.55k|         constexpr bool has_apply_bool = enable_action && internal::has_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.55k|         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.55k|         constexpr bool has_apply0_void = enable_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.55k|         constexpr bool has_apply0_bool = enable_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.55k|         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.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.55k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.55k|         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.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 280, False: 2.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    280|            else if constexpr( has_apply0_bool ) {
  153|    280|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    280|            }
  155|    280|         }
  156|  2.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 280, False: 2.27k]
  ------------------
  157|    280|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    280|         }
  159|  2.27k|         else {
  160|  2.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.27k|         }
  162|  2.55k|         (void)m( result );
  163|  2.55k|         return result;
  164|  2.55k|      }
  165|  2.55k|   }
_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.55k|      {
   73|  2.55k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.55k|         else {
   84|  2.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.55k|      }
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.55k|      {
   59|  2.55k|         return Rule::match( in );
   60|  2.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.27k|      else {
  108|  2.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 209, False: 2.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|    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.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 209, False: 2.06k]
  ------------------
  157|    209|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    209|         }
  159|  2.06k|         else {
  160|  2.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.06k|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.27k|         else {
   84|  2.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.27k|      {
   59|  2.27k|         return Rule::match( in );
   60|  2.27k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.06k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.06k|      else {
  108|  2.06k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.06k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.06k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.06k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.06k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.06k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.06k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.06k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.06k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.06k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.06k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.06k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 234, False: 1.82k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    234|            else if constexpr( has_apply0_bool ) {
  153|    234|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    234|            }
  155|    234|         }
  156|  2.06k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 234, False: 1.82k]
  ------------------
  157|    234|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    234|         }
  159|  1.82k|         else {
  160|  1.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.82k|         }
  162|  2.06k|         (void)m( result );
  163|  2.06k|         return result;
  164|  2.06k|      }
  165|  2.06k|   }
_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.06k|      {
   73|  2.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|  2.06k|         else {
   84|  2.06k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.06k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.06k|      }
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.06k|      {
   59|  2.06k|         return Rule::match( in );
   60|  2.06k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.18k|      else {
  108|  3.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.85k, False: 1.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|  1.85k|            else if constexpr( has_apply0_bool ) {
  153|  1.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.85k|            }
  155|  1.85k|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.85k, False: 1.33k]
  ------------------
  157|  1.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.85k|         }
  159|  1.33k|         else {
  160|  1.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.33k|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_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.18k|      {
   73|  3.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|  3.18k|         else {
   84|  3.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.18k|      }
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.18k|      {
   59|  3.18k|         return Rule::match( in );
   60|  3.18k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.66k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.66k|      else {
  108|  3.66k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.66k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.66k|         constexpr bool has_apply_void = enable_action && internal::has_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.66k|         constexpr bool has_apply_bool = enable_action && internal::has_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.66k|         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.66k|         constexpr bool has_apply0_void = enable_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.66k|         constexpr bool has_apply0_bool = enable_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.66k|         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.66k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.66k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.66k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.66k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.66k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.66k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.66k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.66k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.66k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.66k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.66k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.66k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.66k, 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.66k|            else if constexpr( has_apply0_bool ) {
  153|  3.66k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.66k|            }
  155|  3.66k|         }
  156|  3.66k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.66k, False: 0]
  ------------------
  157|  3.66k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.66k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.66k|         (void)m( result );
  163|  3.66k|         return result;
  164|  3.66k|      }
  165|  3.66k|   }
_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.66k|      {
   73|  3.66k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.66k|         else {
   84|  3.66k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.66k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.66k|      }
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.66k|      {
   44|  3.66k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.66k|      }
_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.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.85k|      else {
  108|  1.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.85k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.80k, False: 44]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.80k, False: 44]
  ------------------
  157|  1.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.80k|         }
  159|     44|         else {
  160|     44|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     44|         }
  162|  1.85k|         (void)m( result );
  163|  1.85k|         return result;
  164|  1.85k|      }
  165|  1.85k|   }
_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.85k|      {
   73|  1.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.85k|         else {
   84|  1.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.85k|      {
   44|  1.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.85k|      }
_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.81k|   {
  104|  1.81k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.81k|   }
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.81k|      {
   44|  1.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.81k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.71k|   {
  104|  3.71k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.71k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.71k|      {
   44|  3.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.80k|      else {
  108|  1.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.80k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.80k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.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|  1.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|  1.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|  1.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|  1.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.80k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.80k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70k, False: 100]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.70k|            else if constexpr( has_apply0_bool ) {
  153|  1.70k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70k|            }
  155|  1.70k|         }
  156|  1.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70k, False: 100]
  ------------------
  157|  1.70k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70k|         }
  159|    100|         else {
  160|    100|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    100|         }
  162|  1.80k|         (void)m( result );
  163|  1.80k|         return result;
  164|  1.80k|      }
  165|  1.80k|   }
_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.80k|      {
   73|  1.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|  1.80k|         else {
   84|  1.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.80k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.80k|      {
   59|  1.80k|         return Rule::match( in );
   60|  1.80k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.51k|      else {
  108|  5.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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): [True: 0, Folded]
  ------------------
  112|  5.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|  5.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.51k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.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|  5.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|  5.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|  5.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.51k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.74k, False: 773]
  ------------------
  143|  4.74k|            if constexpr( has_apply_void ) {
  144|  4.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|  4.74k|         }
  156|  5.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.73k, False: 782]
  ------------------
  157|  4.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.73k|         }
  159|    782|         else {
  160|    782|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    782|         }
  162|  5.51k|         (void)m( result );
  163|  5.51k|         return result;
  164|  5.51k|      }
  165|  5.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.51k|      {
   73|  5.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|  5.51k|         else {
   84|  5.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.51k|      {
   44|  5.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.51k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.51k|      else {
  108|  5.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.95k, False: 562]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.95k|            else if constexpr( has_apply0_bool ) {
  153|  4.95k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.95k|            }
  155|  4.95k|         }
  156|  5.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.95k, False: 562]
  ------------------
  157|  4.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.95k|         }
  159|    562|         else {
  160|    562|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    562|         }
  162|  5.51k|         (void)m( result );
  163|  5.51k|         return result;
  164|  5.51k|      }
  165|  5.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.51k|      {
   73|  5.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|  5.51k|         else {
   84|  5.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.51k|      {
   59|  5.51k|         return Rule::match( in );
   60|  5.51k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.95k|   {
  104|  4.95k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.95k|         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.95k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.95k|      {
   44|  4.95k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.95k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  4.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.95k|      else {
  108|  4.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.95k|         constexpr bool has_apply_void = enable_action && internal::has_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.95k|         constexpr bool has_apply_bool = enable_action && internal::has_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.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.74k, False: 211]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.74k|            else if constexpr( has_apply0_bool ) {
  153|  4.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.74k|            }
  155|  4.74k|         }
  156|  4.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.74k, False: 211]
  ------------------
  157|  4.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.74k|         }
  159|    211|         else {
  160|    211|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    211|         }
  162|  4.95k|         (void)m( result );
  163|  4.95k|         return result;
  164|  4.95k|      }
  165|  4.95k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  4.95k|      {
   73|  4.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  4.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.95k|      {
   44|  4.95k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.95k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.67M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.67M|      else {
  108|  2.67M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.67M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.67M|         constexpr bool has_apply_void = enable_action && internal::has_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.67M|         constexpr bool has_apply_bool = enable_action && internal::has_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.67M|         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.67M|         constexpr bool has_apply0_void = enable_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.67M|         constexpr bool has_apply0_bool = enable_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.67M|         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.67M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.67M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.67M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.67M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.67M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.67M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.67M|         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.67M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.67M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.67M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.67M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.67M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.74k, False: 2.66M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.74k|            else if constexpr( has_apply0_bool ) {
  153|  4.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.74k|            }
  155|  4.74k|         }
  156|  2.67M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.74k, False: 2.66M]
  ------------------
  157|  4.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.74k|         }
  159|  2.66M|         else {
  160|  2.66M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.66M|         }
  162|  2.67M|         (void)m( result );
  163|  2.67M|         return result;
  164|  2.67M|      }
  165|  2.67M|   }
_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.67M|      {
   73|  2.67M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.67M|         else {
   84|  2.67M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.67M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.67M|      }
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.67M|      {
   59|  2.67M|         return Rule::match( in );
   60|  2.67M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.66M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.66M|      else {
  108|  2.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.66M|         constexpr bool has_apply_void = enable_action && internal::has_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.66M|         constexpr bool has_apply_bool = enable_action && internal::has_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.66M|         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.66M|         constexpr bool has_apply0_void = enable_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.66M|         constexpr bool has_apply0_bool = enable_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.66M|         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.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.66M, False: 211]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.66M|            else if constexpr( has_apply0_bool ) {
  153|  2.66M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.66M|            }
  155|  2.66M|         }
  156|  2.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.66M, False: 211]
  ------------------
  157|  2.66M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.66M|         }
  159|    211|         else {
  160|    211|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    211|         }
  162|  2.66M|         (void)m( result );
  163|  2.66M|         return result;
  164|  2.66M|      }
  165|  2.66M|   }
_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.66M|      {
   73|  2.66M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.66M|         else {
   84|  2.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.66M|      }
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.66M|      {
   44|  2.66M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.66M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.66M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.66M|      else {
  108|  2.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.66M|         constexpr bool has_apply_void = enable_action && internal::has_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.66M|         constexpr bool has_apply_bool = enable_action && internal::has_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.66M|         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.66M|         constexpr bool has_apply0_void = enable_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.66M|         constexpr bool has_apply0_bool = enable_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.66M|         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.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.31k, False: 2.66M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.31k|            else if constexpr( has_apply0_bool ) {
  153|  8.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.31k|            }
  155|  8.31k|         }
  156|  2.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.31k, False: 2.66M]
  ------------------
  157|  8.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.31k|         }
  159|  2.66M|         else {
  160|  2.66M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.66M|         }
  162|  2.66M|         (void)m( result );
  163|  2.66M|         return result;
  164|  2.66M|      }
  165|  2.66M|   }
_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.66M|      {
   73|  2.66M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.66M|         else {
   84|  2.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.66M|      }
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.66M|      {
   44|  2.66M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.66M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.66M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.66M|      else {
  108|  2.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.66M|         constexpr bool has_apply_void = enable_action && internal::has_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.66M|         constexpr bool has_apply_bool = enable_action && internal::has_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.66M|         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.66M|         constexpr bool has_apply0_void = enable_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.66M|         constexpr bool has_apply0_bool = enable_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.66M|         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.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.36k, False: 2.66M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.36k|            else if constexpr( has_apply0_bool ) {
  153|  8.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.36k|            }
  155|  8.36k|         }
  156|  2.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.36k, False: 2.66M]
  ------------------
  157|  8.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.36k|         }
  159|  2.66M|         else {
  160|  2.66M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.66M|         }
  162|  2.66M|         (void)m( result );
  163|  2.66M|         return result;
  164|  2.66M|      }
  165|  2.66M|   }
_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.66M|      {
   73|  2.66M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.66M|         else {
   84|  2.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.66M|      }
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.66M|      {
   59|  2.66M|         return Rule::match( in );
   60|  2.66M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  8.36k|   {
  104|  8.36k|      if constexpr( !Control< Rule >::enable ) {
  105|  8.36k|         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.36k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.36k|      {
   44|  8.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.36k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  8.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.36k|      else {
  108|  8.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.31k, 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|  8.31k|            else if constexpr( has_apply0_bool ) {
  153|  8.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.31k|            }
  155|  8.31k|         }
  156|  8.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.31k, False: 52]
  ------------------
  157|  8.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.31k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  8.36k|         (void)m( result );
  163|  8.36k|         return result;
  164|  8.36k|      }
  165|  8.36k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  8.36k|      {
   73|  8.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|  8.36k|         else {
   84|  8.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.36k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.36k|      {
   44|  8.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.36k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.36k|      else {
  108|  8.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, False: 5.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|  2.99k|            else if constexpr( has_apply0_bool ) {
  153|  2.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.99k|            }
  155|  2.99k|         }
  156|  8.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 5.37k]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|  5.37k|         else {
  160|  5.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.37k|         }
  162|  8.36k|         (void)m( result );
  163|  8.36k|         return result;
  164|  8.36k|      }
  165|  8.36k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.36k|      {
   73|  8.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|  8.36k|         else {
   84|  8.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.36k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.36k|      {
   44|  8.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.36k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.36k|      else {
  108|  8.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.01k, False: 5.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|  3.01k|            else if constexpr( has_apply0_bool ) {
  153|  3.01k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.01k|            }
  155|  3.01k|         }
  156|  8.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.01k, False: 5.34k]
  ------------------
  157|  3.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.01k|         }
  159|  5.34k|         else {
  160|  5.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.34k|         }
  162|  8.36k|         (void)m( result );
  163|  8.36k|         return result;
  164|  8.36k|      }
  165|  8.36k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.36k|      {
   73|  8.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|  8.36k|         else {
   84|  8.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.36k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.36k|      {
   59|  8.36k|         return Rule::match( in );
   60|  8.36k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|  3.01k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.01k|         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.01k|   }
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|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.99k|            else if constexpr( has_apply0_bool ) {
  153|  2.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.99k|            }
  155|  2.99k|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 24]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_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|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  3.01k|      {
   44|  3.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.01k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.02k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.02k|      else {
  108|  6.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.02k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.02k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.02k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.02k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.00k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.00k|            else if constexpr( has_apply0_bool ) {
  153|  6.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.00k|            }
  155|  6.00k|         }
  156|  6.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.00k, False: 24]
  ------------------
  157|  6.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.00k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  6.02k|         (void)m( result );
  163|  6.02k|         return result;
  164|  6.02k|      }
  165|  6.02k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.02k|      {
   73|  6.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|  6.02k|         else {
   84|  6.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.02k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.02k|      {
   59|  6.02k|         return Rule::match( in );
   60|  6.02k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.34k|      else {
  108|  5.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.51k, False: 3.82k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.51k|            else if constexpr( has_apply0_bool ) {
  153|  1.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.51k|            }
  155|  1.51k|         }
  156|  5.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.51k, False: 3.82k]
  ------------------
  157|  1.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.51k|         }
  159|  3.82k|         else {
  160|  3.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.82k|         }
  162|  5.34k|         (void)m( result );
  163|  5.34k|         return result;
  164|  5.34k|      }
  165|  5.34k|   }
_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|  5.34k|      {
   73|  5.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|  5.34k|         else {
   84|  5.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.34k|      }
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|  5.34k|      {
   44|  5.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  7.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.30k|      else {
  108|  7.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.33k, False: 4.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|  2.33k|            else if constexpr( has_apply0_bool ) {
  153|  2.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.33k|            }
  155|  2.33k|         }
  156|  7.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.33k, False: 4.97k]
  ------------------
  157|  2.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.33k|         }
  159|  4.97k|         else {
  160|  4.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.97k|         }
  162|  7.30k|         (void)m( result );
  163|  7.30k|         return result;
  164|  7.30k|      }
  165|  7.30k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  7.30k|      {
   73|  7.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|  7.30k|         else {
   84|  7.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.30k|      }
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|  7.30k|      {
   59|  7.30k|         return Rule::match( in );
   60|  7.30k|      }
_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|  1.51k|   {
  104|  1.51k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.51k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.51k|   }
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|  1.51k|      {
   44|  1.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.51k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.51k|      else {
  108|  1.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.51k, 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.51k|            else if constexpr( has_apply0_bool ) {
  153|  1.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.51k|            }
  155|  1.51k|         }
  156|  1.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.51k, False: 0]
  ------------------
  157|  1.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.51k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  1.51k|         (void)m( result );
  163|  1.51k|         return result;
  164|  1.51k|      }
  165|  1.51k|   }
_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|  1.51k|      {
   73|  1.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|  1.51k|         else {
   84|  1.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.51k|      }
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|  1.51k|      {
   44|  1.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.82k|      else {
  108|  3.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.55k, False: 270]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.55k|            else if constexpr( has_apply0_bool ) {
  153|  3.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.55k|            }
  155|  3.55k|         }
  156|  3.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.55k, False: 270]
  ------------------
  157|  3.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.55k|         }
  159|    270|         else {
  160|    270|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    270|         }
  162|  3.82k|         (void)m( result );
  163|  3.82k|         return result;
  164|  3.82k|      }
  165|  3.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.82k|      {
   73|  3.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|  3.82k|         else {
   84|  3.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.82k|      {
   59|  3.82k|         return Rule::match( in );
   60|  3.82k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    270|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    270|      else {
  108|    270|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    270|         using iterator_t = typename ParseInput::iterator_t;
  111|    270|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    270|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    270|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    270|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    270|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    270|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    270|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    270|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    270|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    270|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    270|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    270|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    270|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    270|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    270|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    270|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    270|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    270|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 242, False: 28]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    242|            else if constexpr( has_apply0_bool ) {
  153|    242|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    242|            }
  155|    242|         }
  156|    270|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 242, False: 28]
  ------------------
  157|    242|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    242|         }
  159|     28|         else {
  160|     28|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     28|         }
  162|    270|         (void)m( result );
  163|    270|         return result;
  164|    270|      }
  165|    270|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    270|      {
   73|    270|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    270|         else {
   84|    270|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    270|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    270|      }
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|    270|      {
   59|    270|         return Rule::match( in );
   60|    270|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.66M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.66M|      else {
  108|  2.66M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.66M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.66M|         constexpr bool has_apply_void = enable_action && internal::has_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.66M|         constexpr bool has_apply_bool = enable_action && internal::has_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.66M|         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.66M|         constexpr bool has_apply0_void = enable_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.66M|         constexpr bool has_apply0_bool = enable_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.66M|         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.66M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.66M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.66M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.66M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.66M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.66M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.66M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.66M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.66M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.66M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.66M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.66M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.66M, False: 159]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.66M|            else if constexpr( has_apply0_bool ) {
  153|  2.66M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.66M|            }
  155|  2.66M|         }
  156|  2.66M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.66M, False: 159]
  ------------------
  157|  2.66M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.66M|         }
  159|    159|         else {
  160|    159|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    159|         }
  162|  2.66M|         (void)m( result );
  163|  2.66M|         return result;
  164|  2.66M|      }
  165|  2.66M|   }
_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.66M|      {
   73|  2.66M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.66M|         else {
   84|  2.66M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.66M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.66M|      }
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.66M|      {
   59|  2.66M|         return Rule::match( in );
   60|  2.66M|      }
_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|  28.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.2k|      else {
  108|  28.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.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|  28.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|  28.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|  28.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|  28.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|  28.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|  28.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.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|  28.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.26k, False: 25.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.26k|            else if constexpr( has_apply0_bool ) {
  153|  3.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.26k|            }
  155|  3.26k|         }
  156|  28.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.26k, False: 25.0k]
  ------------------
  157|  3.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.26k|         }
  159|  25.0k|         else {
  160|  25.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.0k|         }
  162|  28.2k|         (void)m( result );
  163|  28.2k|         return result;
  164|  28.2k|      }
  165|  28.2k|   }
_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|  28.2k|      {
   73|  28.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|  28.2k|         else {
   84|  28.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.2k|      }
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|  28.2k|      {
   44|  28.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.2k|      }
_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|  28.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.2k|      else {
  108|  28.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.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|  28.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|  28.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|  28.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|  28.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|  28.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|  28.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.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|  28.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.26k, False: 25.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.26k|            else if constexpr( has_apply0_bool ) {
  153|  3.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.26k|            }
  155|  3.26k|         }
  156|  28.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.26k, False: 25.0k]
  ------------------
  157|  3.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.26k|         }
  159|  25.0k|         else {
  160|  25.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.0k|         }
  162|  28.2k|         (void)m( result );
  163|  28.2k|         return result;
  164|  28.2k|      }
  165|  28.2k|   }
_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|  28.2k|      {
   73|  28.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|  28.2k|         else {
   84|  28.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.2k|      }
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|  28.2k|      {
   44|  28.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.2k|      }
_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|  28.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.2k|      else {
  108|  28.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  28.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|  28.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 28.2k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  28.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|  28.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|  28.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|  28.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.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|  28.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 28.2k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.96k, False: 24.2k]
  ------------------
  143|  3.96k|            if constexpr( has_apply_void ) {
  144|  3.96k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.96k|         }
  156|  28.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.96k, False: 24.2k]
  ------------------
  157|  3.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.96k|         }
  159|  24.2k|         else {
  160|  24.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.2k|         }
  162|  28.2k|         (void)m( result );
  163|  28.2k|         return result;
  164|  28.2k|      }
  165|  28.2k|   }
_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|  28.2k|      {
   73|  28.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|  28.2k|         else {
   84|  28.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.2k|      }
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|  28.2k|      {
   59|  28.2k|         return Rule::match( in );
   60|  28.2k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  10.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.7k|      else {
  108|  10.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.04k, 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|  9.04k|            else if constexpr( has_apply0_bool ) {
  153|  9.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.04k|            }
  155|  9.04k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.04k, False: 1.71k]
  ------------------
  157|  9.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.04k|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  10.7k|         (void)m( result );
  163|  10.7k|         return result;
  164|  10.7k|      }
  165|  10.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.7k|      {
   73|  10.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.7k|         else {
   84|  10.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_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|  10.7k|      {
   44|  10.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.7k|      else {
  108|  10.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.04k, 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|  9.04k|            else if constexpr( has_apply0_bool ) {
  153|  9.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.04k|            }
  155|  9.04k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.04k, False: 1.71k]
  ------------------
  157|  9.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.04k|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  10.7k|         (void)m( result );
  163|  10.7k|         return result;
  164|  10.7k|      }
  165|  10.7k|   }
_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|  10.7k|      {
   73|  10.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.7k|         else {
   84|  10.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.7k|      {
   59|  10.7k|         return Rule::match( in );
   60|  10.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  20.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.7k|      else {
  108|  20.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  20.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  20.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  20.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  20.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  20.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  20.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  20.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  20.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.39k, False: 14.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|  6.39k|            else if constexpr( has_apply0_bool ) {
  153|  6.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.39k|            }
  155|  6.39k|         }
  156|  20.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.39k, False: 14.3k]
  ------------------
  157|  6.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.39k|         }
  159|  14.3k|         else {
  160|  14.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.3k|         }
  162|  20.7k|         (void)m( result );
  163|  20.7k|         return result;
  164|  20.7k|      }
  165|  20.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  20.7k|      {
   73|  20.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  20.7k|         else {
   84|  20.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  20.7k|      {
   59|  20.7k|         return Rule::match( in );
   60|  20.7k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.26k, False: 685]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.26k|            else if constexpr( has_apply0_bool ) {
  153|  3.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.26k|            }
  155|  3.26k|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.26k, False: 685]
  ------------------
  157|  3.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.26k|         }
  159|    685|         else {
  160|    685|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    685|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.94k|      {
   44|  3.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.94k|      }
_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.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.48k, 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|  2.48k|            else if constexpr( has_apply0_bool ) {
  153|  2.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.48k|            }
  155|  2.48k|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.48k, False: 1.45k]
  ------------------
  157|  2.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.48k|         }
  159|  1.45k|         else {
  160|  1.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.45k|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.94k|      {
   44|  3.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.94k|      }
_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.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.94k, 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.94k|            else if constexpr( has_apply0_bool ) {
  153|  3.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.94k|            }
  155|  3.94k|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.94k, False: 0]
  ------------------
  157|  3.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.94k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.94k|      {
   44|  3.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.94k|      }
_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.94k|   {
  104|  3.94k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.94k|         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.94k|   }
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.94k|      {
   44|  3.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.94k|      }
_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.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.94k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.94k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.54k, False: 2.39k]
  ------------------
  143|  1.54k|            if constexpr( has_apply_void ) {
  144|  1.54k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.54k|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.54k, False: 2.39k]
  ------------------
  157|  1.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.54k|         }
  159|  2.39k|         else {
  160|  2.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.39k|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.94k|      {
   44|  3.94k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.94k|      }
_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.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 220, 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|    220|            else if constexpr( has_apply0_bool ) {
  153|    220|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    220|            }
  155|    220|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 3.72k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  3.72k|         else {
  160|  3.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.72k|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.94k|      {
   59|  3.94k|         return Rule::match( in );
   60|  3.94k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.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: 250, 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|    250|            else if constexpr( has_apply0_bool ) {
  153|    250|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    250|            }
  155|    250|         }
  156|  3.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 250, False: 3.47k]
  ------------------
  157|    250|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    250|         }
  159|  3.47k|         else {
  160|  3.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.47k|         }
  162|  3.72k|         (void)m( result );
  163|  3.72k|         return result;
  164|  3.72k|      }
  165|  3.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.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_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.72k|      {
   59|  3.72k|         return Rule::match( in );
   60|  3.72k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.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: 195, False: 3.28k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  3.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 3.28k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  3.28k|         else {
  160|  3.28k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.28k|         }
  162|  3.47k|         (void)m( result );
  163|  3.47k|         return result;
  164|  3.47k|      }
  165|  3.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.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_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.47k|      {
   59|  3.47k|         return Rule::match( in );
   60|  3.47k|      }
_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|  3.28k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.28k|      else {
  108|  3.28k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.28k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.28k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.28k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.28k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.28k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.28k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.28k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.28k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.28k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.28k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.28k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.28k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.28k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.28k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.28k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.28k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.28k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.28k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.28k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 334, 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|    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|  3.28k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 334, False: 2.94k]
  ------------------
  157|    334|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    334|         }
  159|  2.94k|         else {
  160|  2.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.94k|         }
  162|  3.28k|         (void)m( result );
  163|  3.28k|         return result;
  164|  3.28k|      }
  165|  3.28k|   }
_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|  3.28k|      {
   73|  3.28k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.28k|         else {
   84|  3.28k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.28k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.28k|      }
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|  3.28k|      {
   59|  3.28k|         return Rule::match( in );
   60|  3.28k|      }
_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.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: 269, False: 2.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    269|            else if constexpr( has_apply0_bool ) {
  153|    269|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    269|            }
  155|    269|         }
  156|  2.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 269, False: 2.67k]
  ------------------
  157|    269|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    269|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  2.94k|         (void)m( result );
  163|  2.94k|         return result;
  164|  2.94k|      }
  165|  2.94k|   }
_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.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_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.94k|      {
   59|  2.94k|         return Rule::match( in );
   60|  2.94k|      }
_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.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.67k|      else {
  108|  2.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 279, False: 2.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|    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.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 279, False: 2.39k]
  ------------------
  157|    279|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    279|         }
  159|  2.39k|         else {
  160|  2.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.39k|         }
  162|  2.67k|         (void)m( result );
  163|  2.67k|         return result;
  164|  2.67k|      }
  165|  2.67k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.67k|      {
   73|  2.67k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.67k|         else {
   84|  2.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.67k|      {
   59|  2.67k|         return Rule::match( in );
   60|  2.67k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.94k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.71k, 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|  2.71k|            else if constexpr( has_apply0_bool ) {
  153|  2.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.71k|            }
  155|  2.71k|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.71k, False: 1.23k]
  ------------------
  157|  2.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.71k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_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.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.94k|      {
   59|  3.94k|         return Rule::match( in );
   60|  3.94k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.34k|      else {
  108|  5.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.34k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.34k|            else if constexpr( has_apply0_bool ) {
  153|  5.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.34k|            }
  155|  5.34k|         }
  156|  5.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.34k, False: 0]
  ------------------
  157|  5.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.34k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.34k|         (void)m( result );
  163|  5.34k|         return result;
  164|  5.34k|      }
  165|  5.34k|   }
_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|  5.34k|      {
   73|  5.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|  5.34k|         else {
   84|  5.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.34k|      }
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|  5.34k|      {
   44|  5.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.34k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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: 2.63k, False: 82]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.63k|            else if constexpr( has_apply0_bool ) {
  153|  2.63k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.63k|            }
  155|  2.63k|         }
  156|  2.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.63k, False: 82]
  ------------------
  157|  2.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.63k|         }
  159|     82|         else {
  160|     82|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     82|         }
  162|  2.71k|         (void)m( result );
  163|  2.71k|         return result;
  164|  2.71k|      }
  165|  2.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.71k|      {
   44|  2.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.71k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.64k|   {
  104|  2.64k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.64k|         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.64k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.64k|      {
   44|  2.64k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.64k|      }
_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|  5.24k|   {
  104|  5.24k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.24k|         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.24k|   }
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|  5.24k|      {
   44|  5.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.24k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 2.48k, False: 144]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.48k|            else if constexpr( has_apply0_bool ) {
  153|  2.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.48k|            }
  155|  2.48k|         }
  156|  2.63k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.48k, False: 144]
  ------------------
  157|  2.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.48k|         }
  159|    144|         else {
  160|    144|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    144|         }
  162|  2.63k|         (void)m( result );
  163|  2.63k|         return result;
  164|  2.63k|      }
  165|  2.63k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.63k|      {
   59|  2.63k|         return Rule::match( in );
   60|  2.63k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.73k|      else {
  108|  7.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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): [True: 0, Folded]
  ------------------
  112|  7.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|  7.73k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.73k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.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|  7.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|  7.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|  7.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.73k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.07k, False: 1.66k]
  ------------------
  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|  7.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.01k, False: 1.71k]
  ------------------
  157|  6.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.01k|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  7.73k|         (void)m( result );
  163|  7.73k|         return result;
  164|  7.73k|      }
  165|  7.73k|   }
_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|  7.73k|      {
   73|  7.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|  7.73k|         else {
   84|  7.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.73k|      }
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|  7.73k|      {
   44|  7.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.73k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.73k|      else {
  108|  7.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.35k, False: 1.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|  6.35k|            else if constexpr( has_apply0_bool ) {
  153|  6.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.35k|            }
  155|  6.35k|         }
  156|  7.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.35k, False: 1.38k]
  ------------------
  157|  6.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.35k|         }
  159|  1.38k|         else {
  160|  1.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.38k|         }
  162|  7.73k|         (void)m( result );
  163|  7.73k|         return result;
  164|  7.73k|      }
  165|  7.73k|   }
_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|  7.73k|      {
   73|  7.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|  7.73k|         else {
   84|  7.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.73k|      }
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|  7.73k|      {
   59|  7.73k|         return Rule::match( in );
   60|  7.73k|      }
_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|  6.35k|   {
  104|  6.35k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.35k|         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.35k|   }
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|  6.35k|      {
   44|  6.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.35k|      }
_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|  6.35k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.35k|      else {
  108|  6.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.35k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.07k, 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|  6.07k|            else if constexpr( has_apply0_bool ) {
  153|  6.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.07k|            }
  155|  6.07k|         }
  156|  6.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.07k, False: 277]
  ------------------
  157|  6.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.07k|         }
  159|    277|         else {
  160|    277|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    277|         }
  162|  6.35k|         (void)m( result );
  163|  6.35k|         return result;
  164|  6.35k|      }
  165|  6.35k|   }
_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|  6.35k|      {
   73|  6.35k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.35k|         else {
   84|  6.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.35k|      }
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|  6.35k|      {
   44|  6.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.35k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.02M|      else {
  108|  9.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.02M|         constexpr bool has_apply_void = enable_action && internal::has_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.02M|         constexpr bool has_apply_bool = enable_action && internal::has_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.02M|         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.02M|         constexpr bool has_apply0_void = enable_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.02M|         constexpr bool has_apply0_bool = enable_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.02M|         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.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.02M|         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.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.07k, False: 9.02M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.07k|            else if constexpr( has_apply0_bool ) {
  153|  6.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.07k|            }
  155|  6.07k|         }
  156|  9.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.07k, False: 9.02M]
  ------------------
  157|  6.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.07k|         }
  159|  9.02M|         else {
  160|  9.02M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.02M|         }
  162|  9.02M|         (void)m( result );
  163|  9.02M|         return result;
  164|  9.02M|      }
  165|  9.02M|   }
_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|  9.02M|      {
   73|  9.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.02M|         else {
   84|  9.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.02M|      }
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|  9.02M|      {
   59|  9.02M|         return Rule::match( in );
   60|  9.02M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.02M|      else {
  108|  9.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.02M|         constexpr bool has_apply_void = enable_action && internal::has_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.02M|         constexpr bool has_apply_bool = enable_action && internal::has_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.02M|         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.02M|         constexpr bool has_apply0_void = enable_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.02M|         constexpr bool has_apply0_bool = enable_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.02M|         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.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.02M|         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.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.02M, 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|  9.02M|            else if constexpr( has_apply0_bool ) {
  153|  9.02M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.02M|            }
  155|  9.02M|         }
  156|  9.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.02M, False: 277]
  ------------------
  157|  9.02M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.02M|         }
  159|    277|         else {
  160|    277|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    277|         }
  162|  9.02M|         (void)m( result );
  163|  9.02M|         return result;
  164|  9.02M|      }
  165|  9.02M|   }
_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|  9.02M|      {
   73|  9.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.02M|         else {
   84|  9.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.02M|      }
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|  9.02M|      {
   44|  9.02M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.02M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.02M|      else {
  108|  9.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.02M|         constexpr bool has_apply_void = enable_action && internal::has_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.02M|         constexpr bool has_apply_bool = enable_action && internal::has_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.02M|         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.02M|         constexpr bool has_apply0_void = enable_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.02M|         constexpr bool has_apply0_bool = enable_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.02M|         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.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.02M|         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.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.3k, False: 8.92M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  97.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.3k|            }
  155|  97.3k|         }
  156|  9.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.3k, False: 8.92M]
  ------------------
  157|  97.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.3k|         }
  159|  8.92M|         else {
  160|  8.92M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.92M|         }
  162|  9.02M|         (void)m( result );
  163|  9.02M|         return result;
  164|  9.02M|      }
  165|  9.02M|   }
_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|  9.02M|      {
   73|  9.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.02M|         else {
   84|  9.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.02M|      }
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|  9.02M|      {
   44|  9.02M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.02M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.02M|      else {
  108|  9.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.02M|         constexpr bool has_apply_void = enable_action && internal::has_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.02M|         constexpr bool has_apply_bool = enable_action && internal::has_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.02M|         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.02M|         constexpr bool has_apply0_void = enable_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.02M|         constexpr bool has_apply0_bool = enable_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.02M|         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.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.02M|         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.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.4k, False: 8.92M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  97.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.4k|            }
  155|  97.4k|         }
  156|  9.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.4k, False: 8.92M]
  ------------------
  157|  97.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.4k|         }
  159|  8.92M|         else {
  160|  8.92M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.92M|         }
  162|  9.02M|         (void)m( result );
  163|  9.02M|         return result;
  164|  9.02M|      }
  165|  9.02M|   }
_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|  9.02M|      {
   73|  9.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.02M|         else {
   84|  9.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.02M|      }
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|  9.02M|      {
   59|  9.02M|         return Rule::match( in );
   60|  9.02M|      }
_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|  97.4k|   {
  104|  97.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  97.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|  97.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|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  97.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|  97.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|  97.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|  97.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|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.3k, False: 85]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  97.3k|            else if constexpr( has_apply0_bool ) {
  153|  97.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.3k|            }
  155|  97.3k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.3k, False: 85]
  ------------------
  157|  97.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.3k|         }
  159|     85|         else {
  160|     85|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     85|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  97.4k|      {
   73|  97.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_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|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.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|  97.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  97.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|  97.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|  97.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|  97.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|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.1k, False: 69.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|  28.1k|            else if constexpr( has_apply0_bool ) {
  153|  28.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.1k|            }
  155|  28.1k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.1k, False: 69.2k]
  ------------------
  157|  28.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.1k|         }
  159|  69.2k|         else {
  160|  69.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  69.2k|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.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|  97.4k|      {
   73|  97.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|  97.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_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|  97.4k|      {
   44|  97.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  97.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.4k|      else {
  108|  97.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  97.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  97.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|  97.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|  97.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|  97.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|  97.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  97.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.2k, False: 69.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|  28.2k|            else if constexpr( has_apply0_bool ) {
  153|  28.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.2k|            }
  155|  28.2k|         }
  156|  97.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.2k, False: 69.2k]
  ------------------
  157|  28.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.2k|         }
  159|  69.2k|         else {
  160|  69.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  69.2k|         }
  162|  97.4k|         (void)m( result );
  163|  97.4k|         return result;
  164|  97.4k|      }
  165|  97.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|  97.4k|      {
   73|  97.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|  97.4k|         else {
   84|  97.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  97.4k|      {
   59|  97.4k|         return Rule::match( in );
   60|  97.4k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  28.2k|   {
  104|  28.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  28.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|  28.2k|   }
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|  28.2k|      {
   44|  28.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.2k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  28.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.2k|      else {
  108|  28.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.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|  28.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|  28.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|  28.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|  28.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|  28.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|  28.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.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|  28.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.1k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  28.1k|            else if constexpr( has_apply0_bool ) {
  153|  28.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.1k|            }
  155|  28.1k|         }
  156|  28.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.1k, False: 24]
  ------------------
  157|  28.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.1k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  28.2k|         (void)m( result );
  163|  28.2k|         return result;
  164|  28.2k|      }
  165|  28.2k|   }
_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|  28.2k|      {
   73|  28.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|  28.2k|         else {
   84|  28.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.2k|      }
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|  28.2k|      {
   44|  28.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  56.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  56.3k|      else {
  108|  56.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  56.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  56.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|  56.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|  56.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|  56.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|  56.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|  56.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|  56.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  56.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  56.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  56.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|  56.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  56.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  56.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|  56.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  56.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  56.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  56.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  56.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 56.3k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  56.3k|            else if constexpr( has_apply0_bool ) {
  153|  56.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  56.3k|            }
  155|  56.3k|         }
  156|  56.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 56.3k, False: 24]
  ------------------
  157|  56.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  56.3k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  56.3k|         (void)m( result );
  163|  56.3k|         return result;
  164|  56.3k|      }
  165|  56.3k|   }
_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|  56.3k|      {
   73|  56.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|  56.3k|         else {
   84|  56.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  56.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  56.3k|      }
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|  56.3k|      {
   59|  56.3k|         return Rule::match( in );
   60|  56.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  69.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  69.2k|      else {
  108|  69.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  69.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  69.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|  69.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|  69.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|  69.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|  69.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|  69.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|  69.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  69.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  69.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  69.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|  69.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  69.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  69.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|  69.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  69.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  69.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  69.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  69.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.7k, False: 39.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.7k|            else if constexpr( has_apply0_bool ) {
  153|  29.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.7k|            }
  155|  29.7k|         }
  156|  69.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.7k, False: 39.4k]
  ------------------
  157|  29.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.7k|         }
  159|  39.4k|         else {
  160|  39.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  39.4k|         }
  162|  69.2k|         (void)m( result );
  163|  69.2k|         return result;
  164|  69.2k|      }
  165|  69.2k|   }
_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|  69.2k|      {
   73|  69.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|  69.2k|         else {
   84|  69.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  69.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  69.2k|      }
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|  69.2k|      {
   44|  69.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  69.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   104k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   104k|      else {
  108|   104k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   104k|         using iterator_t = typename ParseInput::iterator_t;
  111|   104k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   104k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   104k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   104k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   104k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   104k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   104k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   104k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   104k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   104k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   104k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   104k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   104k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   104k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   104k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   104k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   104k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   104k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.7k, False: 65.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|  38.7k|            else if constexpr( has_apply0_bool ) {
  153|  38.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.7k|            }
  155|  38.7k|         }
  156|   104k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.7k, False: 65.8k]
  ------------------
  157|  38.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.7k|         }
  159|  65.8k|         else {
  160|  65.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  65.8k|         }
  162|   104k|         (void)m( result );
  163|   104k|         return result;
  164|   104k|      }
  165|   104k|   }
_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|   104k|      {
   73|   104k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   104k|         else {
   84|   104k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   104k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   104k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   104k|      {
   59|   104k|         return Rule::match( in );
   60|   104k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  29.7k|   {
  104|  29.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.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|  29.7k|   }
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|  29.7k|      {
   44|  29.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.7k|      }
_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|  29.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.7k|      else {
  108|  29.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.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|  29.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|  29.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|  29.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|  29.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|  29.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|  29.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.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|  29.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.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|  29.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.7k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.7k|            else if constexpr( has_apply0_bool ) {
  153|  29.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.7k|            }
  155|  29.7k|         }
  156|  29.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.7k, False: 0]
  ------------------
  157|  29.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  29.7k|         (void)m( result );
  163|  29.7k|         return result;
  164|  29.7k|      }
  165|  29.7k|   }
_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|  29.7k|      {
   73|  29.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|  29.7k|         else {
   84|  29.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.7k|      }
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|  29.7k|      {
   44|  29.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 38.8k, False: 642]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.8k|            else if constexpr( has_apply0_bool ) {
  153|  38.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.8k|            }
  155|  38.8k|         }
  156|  39.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.8k, False: 642]
  ------------------
  157|  38.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.8k|         }
  159|    642|         else {
  160|    642|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    642|         }
  162|  39.4k|         (void)m( result );
  163|  39.4k|         return result;
  164|  39.4k|      }
  165|  39.4k|   }
_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|  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_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|  39.4k|      {
   59|  39.4k|         return Rule::match( in );
   60|  39.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    642|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    642|      else {
  108|    642|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    642|         using iterator_t = typename ParseInput::iterator_t;
  111|    642|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    642|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    642|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    642|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    642|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    642|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    642|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    642|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    642|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    642|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    642|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    642|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    642|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    642|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    642|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    642|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    642|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    642|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 581, False: 61]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    581|            else if constexpr( has_apply0_bool ) {
  153|    581|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    581|            }
  155|    581|         }
  156|    642|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 581, False: 61]
  ------------------
  157|    581|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    581|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|    642|         (void)m( result );
  163|    642|         return result;
  164|    642|      }
  165|    642|   }
_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|    642|      {
   73|    642|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    642|         else {
   84|    642|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    642|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    642|      }
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|    642|      {
   59|    642|         return Rule::match( in );
   60|    642|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.92M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.92M|      else {
  108|  8.92M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.92M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.92M|         constexpr bool has_apply_void = enable_action && internal::has_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.92M|         constexpr bool has_apply_bool = enable_action && internal::has_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.92M|         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.92M|         constexpr bool has_apply0_void = enable_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.92M|         constexpr bool has_apply0_bool = enable_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.92M|         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.92M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.92M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.92M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.92M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.92M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.92M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.92M|         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.92M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.92M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.92M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.92M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.92M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.92M, False: 192]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.92M|            else if constexpr( has_apply0_bool ) {
  153|  8.92M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.92M|            }
  155|  8.92M|         }
  156|  8.92M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.92M, False: 192]
  ------------------
  157|  8.92M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.92M|         }
  159|    192|         else {
  160|    192|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    192|         }
  162|  8.92M|         (void)m( result );
  163|  8.92M|         return result;
  164|  8.92M|      }
  165|  8.92M|   }
_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|  8.92M|      {
   73|  8.92M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.92M|         else {
   84|  8.92M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.92M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.92M|      }
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|  8.92M|      {
   59|  8.92M|         return Rule::match( in );
   60|  8.92M|      }
_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|  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.08k, False: 21.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.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 21.5k]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|  21.5k|         else {
  160|  21.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.5k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  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_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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  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.08k, False: 21.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.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 21.5k]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|  21.5k|         else {
  160|  21.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.5k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  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_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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  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: 3.52k, False: 21.1k]
  ------------------
  143|  3.52k|            if constexpr( has_apply_void ) {
  144|  3.52k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.52k|         }
  156|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.52k, False: 21.1k]
  ------------------
  157|  3.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.52k|         }
  159|  21.1k|         else {
  160|  21.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.1k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  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_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|  24.6k|      {
   59|  24.6k|         return Rule::match( in );
   60|  24.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 166k, False: 1.68k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   166k|            else if constexpr( has_apply0_bool ) {
  153|   166k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   166k|            }
  155|   166k|         }
  156|   167k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 166k, False: 1.68k]
  ------------------
  157|   166k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   166k|         }
  159|  1.68k|         else {
  160|  1.68k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.68k|         }
  162|   167k|         (void)m( result );
  163|   167k|         return result;
  164|   167k|      }
  165|   167k|   }
_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|   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_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|   167k|      {
   44|   167k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   167k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_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: 166k, False: 1.68k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   166k|            else if constexpr( has_apply0_bool ) {
  153|   166k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   166k|            }
  155|   166k|         }
  156|   167k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 166k, False: 1.68k]
  ------------------
  157|   166k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   166k|         }
  159|  1.68k|         else {
  160|  1.68k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.68k|         }
  162|   167k|         (void)m( result );
  163|   167k|         return result;
  164|   167k|      }
  165|   167k|   }
_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|   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_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_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|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.64M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.64M|      else {
  108|  1.64M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.64M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.64M|         constexpr bool has_apply_void = enable_action && internal::has_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.64M|         constexpr bool has_apply_bool = enable_action && internal::has_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.64M|         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.64M|         constexpr bool has_apply0_void = enable_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.64M|         constexpr bool has_apply0_bool = enable_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.64M|         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.64M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.64M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.64M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.64M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.64M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.64M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.64M|         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.64M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.64M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.64M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.64M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.64M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.47M, 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|  1.47M|            else if constexpr( has_apply0_bool ) {
  153|  1.47M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.47M|            }
  155|  1.47M|         }
  156|  1.64M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.47M, False: 171k]
  ------------------
  157|  1.47M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.47M|         }
  159|   171k|         else {
  160|   171k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   171k|         }
  162|  1.64M|         (void)m( result );
  163|  1.64M|         return result;
  164|  1.64M|      }
  165|  1.64M|   }
_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.64M|      {
   73|  1.64M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.64M|         else {
   84|  1.64M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.64M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.64M|      }
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.64M|      {
   59|  1.64M|         return Rule::match( in );
   60|  1.64M|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.08k, False: 430]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 430]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|    430|         else {
  160|    430|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    430|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.24k, False: 1.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|  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.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.24k, False: 1.27k]
  ------------------
  157|  2.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.24k|         }
  159|  1.27k|         else {
  160|  1.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.27k|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.51k, 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.51k|            else if constexpr( has_apply0_bool ) {
  153|  3.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.51k|            }
  155|  3.51k|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.51k, False: 0]
  ------------------
  157|  3.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.51k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|  3.51k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.51k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.51k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.51k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.51k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.03k, False: 1.48k]
  ------------------
  143|  2.03k|            if constexpr( has_apply_void ) {
  144|  2.03k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.03k|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.03k, False: 1.48k]
  ------------------
  157|  2.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.03k|         }
  159|  1.48k|         else {
  160|  1.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.48k|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.51k|      {
   44|  3.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 270, False: 3.24k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    270|            else if constexpr( has_apply0_bool ) {
  153|    270|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    270|            }
  155|    270|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 270, False: 3.24k]
  ------------------
  157|    270|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    270|         }
  159|  3.24k|         else {
  160|  3.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.24k|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.51k|      {
   59|  3.51k|         return Rule::match( in );
   60|  3.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.24k|      else {
  108|  3.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 228, 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|    228|            else if constexpr( has_apply0_bool ) {
  153|    228|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    228|            }
  155|    228|         }
  156|  3.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 228, False: 3.01k]
  ------------------
  157|    228|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    228|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  3.24k|         (void)m( result );
  163|  3.24k|         return result;
  164|  3.24k|      }
  165|  3.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.24k|      {
   73|  3.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|  3.24k|         else {
   84|  3.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.24k|      {
   59|  3.24k|         return Rule::match( in );
   60|  3.24k|      }
_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|  3.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 302, 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|    302|            else if constexpr( has_apply0_bool ) {
  153|    302|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    302|            }
  155|    302|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 302, False: 2.71k]
  ------------------
  157|    302|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    302|         }
  159|  2.71k|         else {
  160|  2.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.71k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_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|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.01k|      {
   59|  3.01k|         return Rule::match( in );
   60|  3.01k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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: 303, False: 2.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    303|            else if constexpr( has_apply0_bool ) {
  153|    303|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    303|            }
  155|    303|         }
  156|  2.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 303, False: 2.41k]
  ------------------
  157|    303|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    303|         }
  159|  2.41k|         else {
  160|  2.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.41k|         }
  162|  2.71k|         (void)m( result );
  163|  2.71k|         return result;
  164|  2.71k|      }
  165|  2.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.71k|      {
   59|  2.71k|         return Rule::match( in );
   60|  2.71k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.41k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.41k|      else {
  108|  2.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.41k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 494, False: 1.92k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    494|            else if constexpr( has_apply0_bool ) {
  153|    494|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    494|            }
  155|    494|         }
  156|  2.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 494, False: 1.92k]
  ------------------
  157|    494|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    494|         }
  159|  1.92k|         else {
  160|  1.92k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.92k|         }
  162|  2.41k|         (void)m( result );
  163|  2.41k|         return result;
  164|  2.41k|      }
  165|  2.41k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.41k|      {
   73|  2.41k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.41k|         else {
   84|  2.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.41k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.41k|      {
   59|  2.41k|         return Rule::match( in );
   60|  2.41k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.92k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.92k|      else {
  108|  1.92k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.92k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.92k|         constexpr bool has_apply_void = enable_action && internal::has_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.92k|         constexpr bool has_apply_bool = enable_action && internal::has_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.92k|         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.92k|         constexpr bool has_apply0_void = enable_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.92k|         constexpr bool has_apply0_bool = enable_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.92k|         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.92k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.92k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.92k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.92k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.92k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.92k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.92k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.92k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.92k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.92k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.92k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.92k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 437, False: 1.48k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    437|            else if constexpr( has_apply0_bool ) {
  153|    437|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    437|            }
  155|    437|         }
  156|  1.92k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 437, False: 1.48k]
  ------------------
  157|    437|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    437|         }
  159|  1.48k|         else {
  160|  1.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.48k|         }
  162|  1.92k|         (void)m( result );
  163|  1.92k|         return result;
  164|  1.92k|      }
  165|  1.92k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.92k|      {
   73|  1.92k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.92k|         else {
   84|  1.92k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.92k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.92k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.92k|      {
   59|  1.92k|         return Rule::match( in );
   60|  1.92k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.51k|      else {
  108|  3.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.47k, 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|  2.47k|            else if constexpr( has_apply0_bool ) {
  153|  2.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.47k|            }
  155|  2.47k|         }
  156|  3.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.47k, False: 1.03k]
  ------------------
  157|  2.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.47k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  3.51k|         (void)m( result );
  163|  3.51k|         return result;
  164|  3.51k|      }
  165|  3.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.51k|      {
   73|  3.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|  3.51k|         else {
   84|  3.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.51k|      {
   59|  3.51k|         return Rule::match( in );
   60|  3.51k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.89k|      else {
  108|  4.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.89k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.89k|            else if constexpr( has_apply0_bool ) {
  153|  4.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.89k|            }
  155|  4.89k|         }
  156|  4.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.89k, False: 0]
  ------------------
  157|  4.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.89k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.89k|         (void)m( result );
  163|  4.89k|         return result;
  164|  4.89k|      }
  165|  4.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.89k|      {
   73|  4.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|  4.89k|         else {
   84|  4.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.89k|      {
   44|  4.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.89k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.47k|      else {
  108|  2.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.42k, False: 57]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.42k|            else if constexpr( has_apply0_bool ) {
  153|  2.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.42k|            }
  155|  2.42k|         }
  156|  2.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.42k, False: 57]
  ------------------
  157|  2.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.42k|         }
  159|     57|         else {
  160|     57|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     57|         }
  162|  2.47k|         (void)m( result );
  163|  2.47k|         return result;
  164|  2.47k|      }
  165|  2.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.47k|      {
   73|  2.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|  2.47k|         else {
   84|  2.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.47k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.47k|      {
   44|  2.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.47k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.42k|   {
  104|  2.42k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.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|  2.42k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.42k|      {
   44|  2.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.42k|      }
_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|   162k|   {
  104|   162k|      if constexpr( !Control< Rule >::enable ) {
  105|   162k|         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|   162k|   }
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|   162k|      {
   44|   162k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   162k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.42k|      else {
  108|  2.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.24k, 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|  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.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.24k, False: 176]
  ------------------
  157|  2.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.24k|         }
  159|    176|         else {
  160|    176|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    176|         }
  162|  2.42k|         (void)m( result );
  163|  2.42k|         return result;
  164|  2.42k|      }
  165|  2.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.42k|      {
   73|  2.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|  2.42k|         else {
   84|  2.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.42k|      {
   59|  2.42k|         return Rule::match( in );
   60|  2.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   164k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   164k|      else {
  108|   164k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   164k|         using iterator_t = typename ParseInput::iterator_t;
  111|   164k|         constexpr bool has_apply_void = 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|   164k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   164k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 164k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   164k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   164k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   164k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   164k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   164k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   164k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   164k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   164k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   164k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   164k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   164k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 164k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   164k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   164k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   164k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   164k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 1.25k]
  ------------------
  143|   163k|            if constexpr( has_apply_void ) {
  144|   163k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   163k|         }
  156|   164k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 1.26k]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  1.26k|         else {
  160|  1.26k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.26k|         }
  162|   164k|         (void)m( result );
  163|   164k|         return result;
  164|   164k|      }
  165|   164k|   }
_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|   164k|      {
   73|   164k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   164k|         else {
   84|   164k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   164k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   164k|      }
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|   164k|      {
   44|   164k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   164k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   164k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   164k|      else {
  108|   164k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   164k|         using iterator_t = typename ParseInput::iterator_t;
  111|   164k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   164k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   164k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   164k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   164k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   164k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   164k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   164k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   164k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   164k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   164k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   164k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   164k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   164k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   164k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   164k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   164k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   164k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, 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|   163k|            else if constexpr( has_apply0_bool ) {
  153|   163k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   163k|            }
  155|   163k|         }
  156|   164k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 1.15k]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  1.15k|         else {
  160|  1.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15k|         }
  162|   164k|         (void)m( result );
  163|   164k|         return result;
  164|   164k|      }
  165|   164k|   }
_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|   164k|      {
   73|   164k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   164k|         else {
   84|   164k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   164k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   164k|      }
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|   164k|      {
   44|   164k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   164k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   828k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   828k|      else {
  108|   828k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   828k|         using iterator_t = typename ParseInput::iterator_t;
  111|   828k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   828k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   828k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   828k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   828k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   828k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   828k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   828k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   828k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   828k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   828k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   828k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   828k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   828k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   828k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   828k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   828k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   828k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 675k, False: 153k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   675k|            else if constexpr( has_apply0_bool ) {
  153|   675k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   675k|            }
  155|   675k|         }
  156|   828k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 675k, False: 153k]
  ------------------
  157|   675k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   675k|         }
  159|   153k|         else {
  160|   153k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   153k|         }
  162|   828k|         (void)m( result );
  163|   828k|         return result;
  164|   828k|      }
  165|   828k|   }
_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|   828k|      {
   73|   828k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   828k|         else {
   84|   828k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   828k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   828k|      }
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|   828k|      {
   59|   828k|         return Rule::match( in );
   60|   828k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   326k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   326k|      else {
  108|   326k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   326k|         using iterator_t = typename ParseInput::iterator_t;
  111|   326k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   326k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   326k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   326k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   326k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   326k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   326k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   326k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   326k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   326k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   326k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   326k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   326k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   326k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   326k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   326k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   326k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   326k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 326k, 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|   326k|            else if constexpr( has_apply0_bool ) {
  153|   326k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   326k|            }
  155|   326k|         }
  156|   326k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 326k, False: 62]
  ------------------
  157|   326k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   326k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|   326k|         (void)m( result );
  163|   326k|         return result;
  164|   326k|      }
  165|   326k|   }
_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|   326k|      {
   73|   326k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   326k|         else {
   84|   326k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   326k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   326k|      }
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|   326k|      {
   59|   326k|         return Rule::match( in );
   60|   326k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   326k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   326k|      else {
  108|   326k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   326k|         using iterator_t = typename ParseInput::iterator_t;
  111|   326k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   326k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   326k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   326k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   326k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   326k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   326k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   326k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   326k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   326k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   326k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   326k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   326k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   326k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   326k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   326k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   326k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   326k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 326k, False: 43]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   326k|            else if constexpr( has_apply0_bool ) {
  153|   326k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   326k|            }
  155|   326k|         }
  156|   326k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 326k, False: 43]
  ------------------
  157|   326k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   326k|         }
  159|     43|         else {
  160|     43|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     43|         }
  162|   326k|         (void)m( result );
  163|   326k|         return result;
  164|   326k|      }
  165|   326k|   }
_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|   326k|      {
   73|   326k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   326k|         else {
   84|   326k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   326k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   326k|      }
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|   326k|      {
   44|   326k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   326k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   326k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   326k|      else {
  108|   326k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   326k|         using iterator_t = typename ParseInput::iterator_t;
  111|   326k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   326k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   326k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   326k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   326k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   326k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   326k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   326k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   326k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   326k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   326k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   326k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   326k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   326k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   326k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   326k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   326k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   326k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 174k, False: 152k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   174k|            else if constexpr( has_apply0_bool ) {
  153|   174k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   174k|            }
  155|   174k|         }
  156|   326k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 174k, False: 152k]
  ------------------
  157|   174k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   174k|         }
  159|   152k|         else {
  160|   152k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   152k|         }
  162|   326k|         (void)m( result );
  163|   326k|         return result;
  164|   326k|      }
  165|   326k|   }
_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|   326k|      {
   73|   326k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   326k|         else {
   84|   326k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   326k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   326k|      }
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|   326k|      {
   44|   326k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   326k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   152k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   152k|      else {
  108|   152k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   152k|         using iterator_t = typename ParseInput::iterator_t;
  111|   152k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   152k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   152k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   152k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   152k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   152k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   152k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   152k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   152k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   152k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   152k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   152k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   152k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   152k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   152k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   152k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   152k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   152k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 152k, False: 43]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   152k|            else if constexpr( has_apply0_bool ) {
  153|   152k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   152k|            }
  155|   152k|         }
  156|   152k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 152k, False: 43]
  ------------------
  157|   152k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   152k|         }
  159|     43|         else {
  160|     43|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     43|         }
  162|   152k|         (void)m( result );
  163|   152k|         return result;
  164|   152k|      }
  165|   152k|   }
_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|   152k|      {
   73|   152k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   152k|         else {
   84|   152k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   152k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   152k|      }
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|   152k|      {
   59|   152k|         return Rule::match( in );
   60|   152k|      }
_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|  21.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.5k|      else {
  108|  21.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.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|  21.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|  21.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|  21.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|  21.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|  21.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|  21.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.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|  21.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.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|  21.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.57k, False: 19.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.57k|            else if constexpr( has_apply0_bool ) {
  153|  2.57k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.57k|            }
  155|  2.57k|         }
  156|  21.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.57k, False: 19.0k]
  ------------------
  157|  2.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.57k|         }
  159|  19.0k|         else {
  160|  19.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.0k|         }
  162|  21.5k|         (void)m( result );
  163|  21.5k|         return result;
  164|  21.5k|      }
  165|  21.5k|   }
_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|  21.5k|      {
   73|  21.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|  21.5k|         else {
   84|  21.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.5k|      }
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|  21.5k|      {
   44|  21.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.5k|      }
_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|  21.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.5k|      else {
  108|  21.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.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|  21.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|  21.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|  21.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|  21.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|  21.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|  21.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.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|  21.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.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|  21.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.57k, False: 19.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.57k|            else if constexpr( has_apply0_bool ) {
  153|  2.57k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.57k|            }
  155|  2.57k|         }
  156|  21.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.57k, False: 19.0k]
  ------------------
  157|  2.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.57k|         }
  159|  19.0k|         else {
  160|  19.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.0k|         }
  162|  21.5k|         (void)m( result );
  163|  21.5k|         return result;
  164|  21.5k|      }
  165|  21.5k|   }
_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|  21.5k|      {
   73|  21.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|  21.5k|         else {
   84|  21.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.5k|      }
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|  21.5k|      {
   44|  21.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.5k|      }
_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|  21.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.5k|      else {
  108|  21.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.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): [True: 0, Folded]
  ------------------
  112|  21.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|  21.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 21.5k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  21.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|  21.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|  21.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|  21.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.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|  21.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.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|  21.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 21.5k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.17k, False: 18.3k]
  ------------------
  143|  3.17k|            if constexpr( has_apply_void ) {
  144|  3.17k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.17k|         }
  156|  21.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.17k, False: 18.4k]
  ------------------
  157|  3.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.17k|         }
  159|  18.4k|         else {
  160|  18.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.4k|         }
  162|  21.5k|         (void)m( result );
  163|  21.5k|         return result;
  164|  21.5k|      }
  165|  21.5k|   }
_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|  21.5k|      {
   73|  21.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|  21.5k|         else {
   84|  21.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.5k|      }
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|  21.5k|      {
   59|  21.5k|         return Rule::match( in );
   60|  21.5k|      }
_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|  9.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.01k|      else {
  108|  9.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.01k|         constexpr bool has_apply_void = enable_action && internal::has_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.01k|         constexpr bool has_apply_bool = enable_action && internal::has_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.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.03k, False: 1.97k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.03k|            else if constexpr( has_apply0_bool ) {
  153|  7.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.03k|            }
  155|  7.03k|         }
  156|  9.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.03k, False: 1.97k]
  ------------------
  157|  7.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.03k|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  9.01k|         (void)m( result );
  163|  9.01k|         return result;
  164|  9.01k|      }
  165|  9.01k|   }
_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|  9.01k|      {
   73|  9.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  9.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.01k|      }
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|  9.01k|      {
   44|  9.01k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.01k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.01k|      else {
  108|  9.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.01k|         constexpr bool has_apply_void = enable_action && internal::has_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.01k|         constexpr bool has_apply_bool = enable_action && internal::has_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.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.03k, False: 1.97k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.03k|            else if constexpr( has_apply0_bool ) {
  153|  7.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.03k|            }
  155|  7.03k|         }
  156|  9.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.03k, False: 1.97k]
  ------------------
  157|  7.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.03k|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  9.01k|         (void)m( result );
  163|  9.01k|         return result;
  164|  9.01k|      }
  165|  9.01k|   }
_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|  9.01k|      {
   73|  9.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  9.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.01k|      }
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|  9.01k|      {
   59|  9.01k|         return Rule::match( in );
   60|  9.01k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  19.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.0k|      else {
  108|  19.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.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|  19.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|  19.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|  19.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|  19.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.84k, False: 12.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|  6.84k|            else if constexpr( has_apply0_bool ) {
  153|  6.84k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.84k|            }
  155|  6.84k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.84k, False: 12.1k]
  ------------------
  157|  6.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.84k|         }
  159|  12.1k|         else {
  160|  12.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.1k|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.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|  19.0k|      {
   73|  19.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|  19.0k|         else {
   84|  19.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  19.0k|      {
   59|  19.0k|         return Rule::match( in );
   60|  19.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.57k, False: 592]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.57k|            else if constexpr( has_apply0_bool ) {
  153|  2.57k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.57k|            }
  155|  2.57k|         }
  156|  3.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.57k, False: 592]
  ------------------
  157|  2.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.57k|         }
  159|    592|         else {
  160|    592|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    592|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.16k|      {
   44|  3.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.16k|      }
_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|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.40k, False: 760]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  3.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 760]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|    760|         else {
  160|    760|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    760|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.16k|      {
   44|  3.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.16k|      }
_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|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.16k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.16k|            else if constexpr( has_apply0_bool ) {
  153|  3.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.16k|            }
  155|  3.16k|         }
  156|  3.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.16k, False: 0]
  ------------------
  157|  3.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.16k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.16k|      {
   44|  3.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.16k|      }
_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|  3.16k|   {
  104|  3.16k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.16k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.16k|   }
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|  3.16k|      {
   44|  3.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.16k|      }
_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|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.16k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.16k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.27k, False: 1.88k]
  ------------------
  143|  1.27k|            if constexpr( has_apply_void ) {
  144|  1.27k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.27k|         }
  156|  3.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.27k, False: 1.88k]
  ------------------
  157|  1.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.27k|         }
  159|  1.88k|         else {
  160|  1.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.88k|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.16k|      {
   44|  3.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.16k|      }
_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|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 204, False: 2.95k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 2.95k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  2.95k|         else {
  160|  2.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.95k|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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|  3.16k|      {
   59|  3.16k|         return Rule::match( in );
   60|  3.16k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.95k|      else {
  108|  2.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.95k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.95k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.95k|         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.95k|         constexpr bool has_apply0_void = enable_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.95k|         constexpr bool has_apply0_bool = enable_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.95k|         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.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 95, False: 2.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|     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.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 95, False: 2.86k]
  ------------------
  157|     95|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     95|         }
  159|  2.86k|         else {
  160|  2.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.86k|         }
  162|  2.95k|         (void)m( result );
  163|  2.95k|         return result;
  164|  2.95k|      }
  165|  2.95k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.95k|      {
   73|  2.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.95k|         else {
   84|  2.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.95k|      {
   59|  2.95k|         return Rule::match( in );
   60|  2.95k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.86k|      else {
  108|  2.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 325, False: 2.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    325|            else if constexpr( has_apply0_bool ) {
  153|    325|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    325|            }
  155|    325|         }
  156|  2.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 325, False: 2.53k]
  ------------------
  157|    325|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    325|         }
  159|  2.53k|         else {
  160|  2.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.53k|         }
  162|  2.86k|         (void)m( result );
  163|  2.86k|         return result;
  164|  2.86k|      }
  165|  2.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.86k|      {
   73|  2.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|  2.86k|         else {
   84|  2.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.86k|      {
   59|  2.86k|         return Rule::match( in );
   60|  2.86k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.53k|      else {
  108|  2.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.34k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.34k|         else {
  160|  2.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.34k|         }
  162|  2.53k|         (void)m( result );
  163|  2.53k|         return result;
  164|  2.53k|      }
  165|  2.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.53k|      {
   73|  2.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.53k|         else {
   84|  2.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.53k|      {
   59|  2.53k|         return Rule::match( in );
   60|  2.53k|      }
_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|  2.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.34k|      else {
  108|  2.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 261, False: 2.08k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    261|            else if constexpr( has_apply0_bool ) {
  153|    261|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    261|            }
  155|    261|         }
  156|  2.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 261, False: 2.08k]
  ------------------
  157|    261|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    261|         }
  159|  2.08k|         else {
  160|  2.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.08k|         }
  162|  2.34k|         (void)m( result );
  163|  2.34k|         return result;
  164|  2.34k|      }
  165|  2.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|  2.34k|      {
   73|  2.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.34k|         else {
   84|  2.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  2.34k|      {
   59|  2.34k|         return Rule::match( in );
   60|  2.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|  2.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.08k|      else {
  108|  2.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.08k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.08k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.08k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.08k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.08k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.08k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.08k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.08k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, False: 1.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 1.88k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  1.88k|         else {
  160|  1.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.88k|         }
  162|  2.08k|         (void)m( result );
  163|  2.08k|         return result;
  164|  2.08k|      }
  165|  2.08k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.08k|      {
   73|  2.08k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.08k|         else {
   84|  2.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.08k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.08k|      {
   59|  2.08k|         return Rule::match( in );
   60|  2.08k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.16k|      else {
  108|  3.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.60k, False: 555]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.60k, False: 555]
  ------------------
  157|  2.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.60k|         }
  159|    555|         else {
  160|    555|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    555|         }
  162|  3.16k|         (void)m( result );
  163|  3.16k|         return result;
  164|  3.16k|      }
  165|  3.16k|   }
_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|  3.16k|      {
   73|  3.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|  3.16k|         else {
   84|  3.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.16k|      {
   59|  3.16k|         return Rule::match( in );
   60|  3.16k|      }
_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|  5.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.13k|      else {
  108|  5.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.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|  5.13k|            else if constexpr( has_apply0_bool ) {
  153|  5.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.13k|            }
  155|  5.13k|         }
  156|  5.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.13k, False: 0]
  ------------------
  157|  5.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.13k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.13k|         (void)m( result );
  163|  5.13k|         return result;
  164|  5.13k|      }
  165|  5.13k|   }
_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|  5.13k|      {
   73|  5.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|  5.13k|         else {
   84|  5.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.13k|      }
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|  5.13k|      {
   44|  5.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.13k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.60k|      else {
  108|  2.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.60k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.52k, False: 84]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.52k|            else if constexpr( has_apply0_bool ) {
  153|  2.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.52k|            }
  155|  2.52k|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.52k, False: 84]
  ------------------
  157|  2.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.52k|         }
  159|     84|         else {
  160|     84|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     84|         }
  162|  2.60k|         (void)m( result );
  163|  2.60k|         return result;
  164|  2.60k|      }
  165|  2.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.60k|      {
   73|  2.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.60k|         else {
   84|  2.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.60k|      {
   44|  2.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.60k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.53k|   {
  104|  2.53k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.53k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.53k|      {
   44|  2.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.53k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.56k|   {
  104|  4.56k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.56k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.56k|      {
   44|  4.56k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.56k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.52k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.52k|      else {
  108|  2.52k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.52k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.52k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.52k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.52k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.52k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.52k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.52k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.52k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.52k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.52k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.52k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.52k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.52k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.52k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.52k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.52k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.52k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.52k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.52k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.40k, False: 121]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 121]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|    121|         else {
  160|    121|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    121|         }
  162|  2.52k|         (void)m( result );
  163|  2.52k|         return result;
  164|  2.52k|      }
  165|  2.52k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.52k|      {
   73|  2.52k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.52k|         else {
   84|  2.52k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.52k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.52k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.52k|      {
   59|  2.52k|         return Rule::match( in );
   60|  2.52k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.96k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.96k|      else {
  108|  5.96k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.96k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.96k|         constexpr bool has_apply_void = 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.96k|         constexpr bool has_apply_bool = enable_action && internal::has_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.96k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.96k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.96k|         constexpr bool has_apply0_void = enable_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.96k|         constexpr bool has_apply0_bool = enable_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.96k|         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.96k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.96k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.96k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.96k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.96k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.96k|         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.96k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.96k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.96k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.96k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.96k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.96k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.78k, False: 1.18k]
  ------------------
  143|  4.78k|            if constexpr( has_apply_void ) {
  144|  4.78k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.78k|         }
  156|  5.96k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.73k, False: 1.23k]
  ------------------
  157|  4.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.73k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  5.96k|         (void)m( result );
  163|  5.96k|         return result;
  164|  5.96k|      }
  165|  5.96k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.96k|      {
   73|  5.96k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96k|         else {
   84|  5.96k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.96k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.96k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.96k|      {
   44|  5.96k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.96k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.96k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.96k|      else {
  108|  5.96k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.96k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.96k|         constexpr bool has_apply_void = enable_action && internal::has_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.96k|         constexpr bool has_apply_bool = enable_action && internal::has_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.96k|         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.96k|         constexpr bool has_apply0_void = enable_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.96k|         constexpr bool has_apply0_bool = enable_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.96k|         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.96k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.96k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.96k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.96k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.96k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.96k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.96k|         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.96k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.96k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.96k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.96k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.96k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.03k, False: 930]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.03k|            else if constexpr( has_apply0_bool ) {
  153|  5.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.03k|            }
  155|  5.03k|         }
  156|  5.96k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.03k, False: 930]
  ------------------
  157|  5.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.03k|         }
  159|    930|         else {
  160|    930|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    930|         }
  162|  5.96k|         (void)m( result );
  163|  5.96k|         return result;
  164|  5.96k|      }
  165|  5.96k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.96k|      {
   73|  5.96k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.96k|         else {
   84|  5.96k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.96k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.96k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.96k|      {
   59|  5.96k|         return Rule::match( in );
   60|  5.96k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.03k|   {
  104|  5.03k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.03k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.03k|      {
   44|  5.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.03k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.03k|      else {
  108|  5.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.78k, False: 256]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.78k|            else if constexpr( has_apply0_bool ) {
  153|  4.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.78k|            }
  155|  4.78k|         }
  156|  5.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.78k, False: 256]
  ------------------
  157|  4.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.78k|         }
  159|    256|         else {
  160|    256|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    256|         }
  162|  5.03k|         (void)m( result );
  163|  5.03k|         return result;
  164|  5.03k|      }
  165|  5.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.03k|      {
   73|  5.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|  5.03k|         else {
   84|  5.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.03k|      {
   44|  5.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.03k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.46M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.46M|      else {
  108|  7.46M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.46M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.46M|         constexpr bool has_apply_void = enable_action && internal::has_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.46M|         constexpr bool has_apply_bool = enable_action && internal::has_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.46M|         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.46M|         constexpr bool has_apply0_void = enable_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.46M|         constexpr bool has_apply0_bool = enable_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.46M|         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.46M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.46M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.46M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.46M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.46M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.46M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.46M|         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.46M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.46M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.46M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.46M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.46M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.78k, False: 7.46M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.78k|            else if constexpr( has_apply0_bool ) {
  153|  4.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.78k|            }
  155|  4.78k|         }
  156|  7.46M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.78k, False: 7.46M]
  ------------------
  157|  4.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.78k|         }
  159|  7.46M|         else {
  160|  7.46M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.46M|         }
  162|  7.46M|         (void)m( result );
  163|  7.46M|         return result;
  164|  7.46M|      }
  165|  7.46M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.46M|      {
   73|  7.46M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.46M|         else {
   84|  7.46M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.46M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.46M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.46M|      {
   59|  7.46M|         return Rule::match( in );
   60|  7.46M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.46M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.46M|      else {
  108|  7.46M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.46M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.46M|         constexpr bool has_apply_void = enable_action && internal::has_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.46M|         constexpr bool has_apply_bool = enable_action && internal::has_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.46M|         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.46M|         constexpr bool has_apply0_void = enable_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.46M|         constexpr bool has_apply0_bool = enable_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.46M|         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.46M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.46M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.46M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.46M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.46M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.46M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.46M|         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.46M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.46M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.46M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.46M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.46M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.46M, False: 256]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.46M|            else if constexpr( has_apply0_bool ) {
  153|  7.46M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.46M|            }
  155|  7.46M|         }
  156|  7.46M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.46M, False: 256]
  ------------------
  157|  7.46M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.46M|         }
  159|    256|         else {
  160|    256|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    256|         }
  162|  7.46M|         (void)m( result );
  163|  7.46M|         return result;
  164|  7.46M|      }
  165|  7.46M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.46M|      {
   73|  7.46M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.46M|         else {
   84|  7.46M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.46M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.46M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.46M|      {
   44|  7.46M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.46M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.46M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.46M|      else {
  108|  7.46M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.46M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.46M|         constexpr bool has_apply_void = enable_action && internal::has_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.46M|         constexpr bool has_apply_bool = enable_action && internal::has_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.46M|         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.46M|         constexpr bool has_apply0_void = enable_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.46M|         constexpr bool has_apply0_bool = enable_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.46M|         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.46M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.46M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.46M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.46M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.46M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.46M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.46M|         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.46M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.46M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.46M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.46M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.46M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.4k, False: 7.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|  75.4k|            else if constexpr( has_apply0_bool ) {
  153|  75.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.4k|            }
  155|  75.4k|         }
  156|  7.46M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.4k, False: 7.38M]
  ------------------
  157|  75.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.4k|         }
  159|  7.38M|         else {
  160|  7.38M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.38M|         }
  162|  7.46M|         (void)m( result );
  163|  7.46M|         return result;
  164|  7.46M|      }
  165|  7.46M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.46M|      {
   73|  7.46M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.46M|         else {
   84|  7.46M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.46M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.46M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.46M|      {
   44|  7.46M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.46M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.46M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.46M|      else {
  108|  7.46M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.46M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.46M|         constexpr bool has_apply_void = enable_action && internal::has_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.46M|         constexpr bool has_apply_bool = enable_action && internal::has_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.46M|         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.46M|         constexpr bool has_apply0_void = enable_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.46M|         constexpr bool has_apply0_bool = enable_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.46M|         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.46M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.46M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.46M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.46M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.46M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.46M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.46M|         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.46M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.46M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.46M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.46M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.46M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.4k, False: 7.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|  75.4k|            else if constexpr( has_apply0_bool ) {
  153|  75.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.4k|            }
  155|  75.4k|         }
  156|  7.46M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.4k, False: 7.38M]
  ------------------
  157|  75.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.4k|         }
  159|  7.38M|         else {
  160|  7.38M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.38M|         }
  162|  7.46M|         (void)m( result );
  163|  7.46M|         return result;
  164|  7.46M|      }
  165|  7.46M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.46M|      {
   73|  7.46M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.46M|         else {
   84|  7.46M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.46M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.46M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.46M|      {
   59|  7.46M|         return Rule::match( in );
   60|  7.46M|      }
_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|  75.4k|   {
  104|  75.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  75.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|  75.4k|   }
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|  75.4k|      {
   44|  75.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  75.4k|      }
_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|  75.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.4k|      else {
  108|  75.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.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|  75.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|  75.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|  75.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|  75.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|  75.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|  75.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.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|  75.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.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|  75.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.4k, 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|  75.4k|            else if constexpr( has_apply0_bool ) {
  153|  75.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.4k|            }
  155|  75.4k|         }
  156|  75.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.4k, False: 79]
  ------------------
  157|  75.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.4k|         }
  159|     79|         else {
  160|     79|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     79|         }
  162|  75.4k|         (void)m( result );
  163|  75.4k|         return result;
  164|  75.4k|      }
  165|  75.4k|   }
_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|  75.4k|      {
   73|  75.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|  75.4k|         else {
   84|  75.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.4k|      }
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|  75.4k|      {
   44|  75.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  75.4k|      }
_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|  75.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.4k|      else {
  108|  75.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.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|  75.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|  75.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|  75.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|  75.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|  75.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|  75.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.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|  75.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.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|  75.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.0k, False: 56.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|  19.0k|            else if constexpr( has_apply0_bool ) {
  153|  19.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.0k|            }
  155|  19.0k|         }
  156|  75.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.0k, False: 56.4k]
  ------------------
  157|  19.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.0k|         }
  159|  56.4k|         else {
  160|  56.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  56.4k|         }
  162|  75.4k|         (void)m( result );
  163|  75.4k|         return result;
  164|  75.4k|      }
  165|  75.4k|   }
_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|  75.4k|      {
   73|  75.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|  75.4k|         else {
   84|  75.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.4k|      }
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|  75.4k|      {
   44|  75.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  75.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  75.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.4k|      else {
  108|  75.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.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|  75.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|  75.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|  75.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|  75.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|  75.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|  75.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.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|  75.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.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|  75.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.0k, False: 56.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|  19.0k|            else if constexpr( has_apply0_bool ) {
  153|  19.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.0k|            }
  155|  19.0k|         }
  156|  75.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.0k, False: 56.4k]
  ------------------
  157|  19.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.0k|         }
  159|  56.4k|         else {
  160|  56.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  56.4k|         }
  162|  75.4k|         (void)m( result );
  163|  75.4k|         return result;
  164|  75.4k|      }
  165|  75.4k|   }
_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|  75.4k|      {
   73|  75.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|  75.4k|         else {
   84|  75.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.4k|      }
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|  75.4k|      {
   59|  75.4k|         return Rule::match( in );
   60|  75.4k|      }
_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|  19.0k|   {
  104|  19.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  19.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|  19.0k|   }
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|  19.0k|      {
   44|  19.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.0k|      }
_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|  19.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.0k|      else {
  108|  19.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.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|  19.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|  19.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|  19.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|  19.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.0k, 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|  19.0k|            else if constexpr( has_apply0_bool ) {
  153|  19.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.0k|            }
  155|  19.0k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.0k, False: 35]
  ------------------
  157|  19.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.0k|         }
  159|     35|         else {
  160|     35|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     35|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.0k|   }
_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|  19.0k|      {
   73|  19.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|  19.0k|         else {
   84|  19.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  19.0k|      {
   44|  19.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  38.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.1k|      else {
  108|  38.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.0k, 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|  38.0k|            else if constexpr( has_apply0_bool ) {
  153|  38.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.0k|            }
  155|  38.0k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.0k, False: 35]
  ------------------
  157|  38.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.0k|         }
  159|     35|         else {
  160|     35|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     35|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_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|  38.1k|      {
   73|  38.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.1k|         else {
   84|  38.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  38.1k|      {
   59|  38.1k|         return Rule::match( in );
   60|  38.1k|      }
_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|  56.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  56.4k|      else {
  108|  56.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  56.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  56.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|  56.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|  56.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|  56.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|  56.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|  56.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|  56.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  56.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  56.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  56.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|  56.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  56.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  56.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|  56.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  56.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  56.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  56.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  56.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.6k, False: 31.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|  24.6k|            else if constexpr( has_apply0_bool ) {
  153|  24.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.6k|            }
  155|  24.6k|         }
  156|  56.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.6k, False: 31.8k]
  ------------------
  157|  24.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.6k|         }
  159|  31.8k|         else {
  160|  31.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.8k|         }
  162|  56.4k|         (void)m( result );
  163|  56.4k|         return result;
  164|  56.4k|      }
  165|  56.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|  56.4k|      {
   73|  56.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|  56.4k|         else {
   84|  56.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  56.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  56.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|  56.4k|      {
   44|  56.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  56.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|  85.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  85.2k|      else {
  108|  85.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.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|  85.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|  85.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|  85.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|  85.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|  85.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|  85.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.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|  85.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.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|  85.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  85.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.6k, False: 54.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|  30.6k|            else if constexpr( has_apply0_bool ) {
  153|  30.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.6k|            }
  155|  30.6k|         }
  156|  85.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.6k, False: 54.6k]
  ------------------
  157|  30.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.6k|         }
  159|  54.6k|         else {
  160|  54.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  54.6k|         }
  162|  85.2k|         (void)m( result );
  163|  85.2k|         return result;
  164|  85.2k|      }
  165|  85.2k|   }
_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|  85.2k|      {
   73|  85.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|  85.2k|         else {
   84|  85.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.2k|      }
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|  85.2k|      {
   59|  85.2k|         return Rule::match( in );
   60|  85.2k|      }
_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|  24.6k|   {
  104|  24.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  24.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|  24.6k|   }
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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  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: 24.6k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  24.6k|            else if constexpr( has_apply0_bool ) {
  153|  24.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.6k|            }
  155|  24.6k|         }
  156|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.6k, False: 0]
  ------------------
  157|  24.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.6k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  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_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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  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: 31.2k, False: 598]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  31.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.2k|            }
  155|  31.2k|         }
  156|  31.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.2k, False: 598]
  ------------------
  157|  31.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.2k|         }
  159|    598|         else {
  160|    598|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    598|         }
  162|  31.8k|         (void)m( result );
  163|  31.8k|         return result;
  164|  31.8k|      }
  165|  31.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  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_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|  31.8k|      {
   59|  31.8k|         return Rule::match( in );
   60|  31.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    598|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    598|      else {
  108|    598|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    598|         using iterator_t = typename ParseInput::iterator_t;
  111|    598|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    598|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    598|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    598|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    598|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    598|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    598|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    598|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    598|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    598|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    598|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    598|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    598|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    598|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    598|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    598|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    598|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    598|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 554, False: 44]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    554|            else if constexpr( has_apply0_bool ) {
  153|    554|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    554|            }
  155|    554|         }
  156|    598|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 554, False: 44]
  ------------------
  157|    554|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    554|         }
  159|     44|         else {
  160|     44|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     44|         }
  162|    598|         (void)m( result );
  163|    598|         return result;
  164|    598|      }
  165|    598|   }
_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|    598|      {
   73|    598|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    598|         else {
   84|    598|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    598|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    598|      }
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|    598|      {
   59|    598|         return Rule::match( in );
   60|    598|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.38M|      else {
  108|  7.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.38M, 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|  7.38M|            else if constexpr( has_apply0_bool ) {
  153|  7.38M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.38M|            }
  155|  7.38M|         }
  156|  7.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.38M, False: 177]
  ------------------
  157|  7.38M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.38M|         }
  159|    177|         else {
  160|    177|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    177|         }
  162|  7.38M|         (void)m( result );
  163|  7.38M|         return result;
  164|  7.38M|      }
  165|  7.38M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.38M|      {
   73|  7.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|  7.38M|         else {
   84|  7.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.38M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.38M|      {
   59|  7.38M|         return Rule::match( in );
   60|  7.38M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  18.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.6k|      else {
  108|  18.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.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|  18.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|  18.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|  18.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|  18.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.71k, False: 14.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.71k|            else if constexpr( has_apply0_bool ) {
  153|  3.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.71k|            }
  155|  3.71k|         }
  156|  18.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.71k, False: 14.9k]
  ------------------
  157|  3.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.71k|         }
  159|  14.9k|         else {
  160|  14.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.9k|         }
  162|  18.6k|         (void)m( result );
  163|  18.6k|         return result;
  164|  18.6k|      }
  165|  18.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|  18.6k|      {
   73|  18.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|  18.6k|         else {
   84|  18.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.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|  18.6k|      {
   44|  18.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.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|  18.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.6k|      else {
  108|  18.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.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|  18.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|  18.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|  18.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|  18.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.71k, False: 14.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.71k|            else if constexpr( has_apply0_bool ) {
  153|  3.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.71k|            }
  155|  3.71k|         }
  156|  18.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.71k, False: 14.9k]
  ------------------
  157|  3.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.71k|         }
  159|  14.9k|         else {
  160|  14.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.9k|         }
  162|  18.6k|         (void)m( result );
  163|  18.6k|         return result;
  164|  18.6k|      }
  165|  18.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|  18.6k|      {
   73|  18.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|  18.6k|         else {
   84|  18.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.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|  18.6k|      {
   44|  18.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  18.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.6k|      else {
  108|  18.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 18.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  18.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|  18.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|  18.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|  18.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 18.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.79k, False: 11.9k]
  ------------------
  143|  6.79k|            if constexpr( has_apply_void ) {
  144|  6.79k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.79k|         }
  156|  18.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.78k, False: 11.9k]
  ------------------
  157|  6.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.78k|         }
  159|  11.9k|         else {
  160|  11.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.9k|         }
  162|  18.6k|         (void)m( result );
  163|  18.6k|         return result;
  164|  18.6k|      }
  165|  18.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|  18.6k|      {
   73|  18.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|  18.6k|         else {
   84|  18.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.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|  18.6k|      {
   59|  18.6k|         return Rule::match( in );
   60|  18.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   812k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   812k|      else {
  108|   812k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   812k|         using iterator_t = typename ParseInput::iterator_t;
  111|   812k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   812k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   812k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   812k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   812k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   812k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   812k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   812k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   812k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   812k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   812k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   812k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   812k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   812k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   812k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   812k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   812k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   812k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 809k, False: 2.64k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   809k|            else if constexpr( has_apply0_bool ) {
  153|   809k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   809k|            }
  155|   809k|         }
  156|   812k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 809k, False: 2.64k]
  ------------------
  157|   809k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   809k|         }
  159|  2.64k|         else {
  160|  2.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.64k|         }
  162|   812k|         (void)m( result );
  163|   812k|         return result;
  164|   812k|      }
  165|   812k|   }
_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|   812k|      {
   73|   812k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   812k|         else {
   84|   812k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   812k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   812k|      }
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|   812k|      {
   44|   812k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   812k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   812k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   812k|      else {
  108|   812k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   812k|         using iterator_t = typename ParseInput::iterator_t;
  111|   812k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   812k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   812k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   812k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   812k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   812k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   812k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   812k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   812k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   812k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   812k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   812k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   812k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   812k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   812k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   812k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   812k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   812k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 809k, False: 2.64k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   809k|            else if constexpr( has_apply0_bool ) {
  153|   809k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   809k|            }
  155|   809k|         }
  156|   812k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 809k, False: 2.64k]
  ------------------
  157|   809k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   809k|         }
  159|  2.64k|         else {
  160|  2.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.64k|         }
  162|   812k|         (void)m( result );
  163|   812k|         return result;
  164|   812k|      }
  165|   812k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   812k|      {
   73|   812k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   812k|         else {
   84|   812k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   812k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   812k|      }
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|   812k|      {
   59|   812k|         return Rule::match( in );
   60|   812k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   859k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   859k|      else {
  108|   859k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   859k|         using iterator_t = typename ParseInput::iterator_t;
  111|   859k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   859k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   859k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   859k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   859k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   859k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   859k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   859k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   859k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   859k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   859k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   859k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   859k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   859k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   859k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   859k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   859k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   859k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.4k, False: 816k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   859k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.4k, False: 816k]
  ------------------
  157|  42.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.4k|         }
  159|   816k|         else {
  160|   816k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   816k|         }
  162|   859k|         (void)m( result );
  163|   859k|         return result;
  164|   859k|      }
  165|   859k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   859k|      {
   73|   859k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   859k|         else {
   84|   859k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   859k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   859k|      }
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|   859k|      {
   59|   859k|         return Rule::match( in );
   60|   859k|      }
_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|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.71k, False: 3.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|  3.71k|            else if constexpr( has_apply0_bool ) {
  153|  3.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.71k|            }
  155|  3.71k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.71k, False: 3.04k]
  ------------------
  157|  3.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.71k|         }
  159|  3.04k|         else {
  160|  3.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.04k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_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|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.34k, False: 4.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.34k|            else if constexpr( has_apply0_bool ) {
  153|  2.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.34k|            }
  155|  2.34k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.34k, False: 4.41k]
  ------------------
  157|  2.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.34k|         }
  159|  4.41k|         else {
  160|  4.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.41k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_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|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.76k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.76k|            else if constexpr( has_apply0_bool ) {
  153|  6.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.76k|            }
  155|  6.76k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.76k, False: 0]
  ------------------
  157|  6.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.76k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_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|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|  6.76k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.76k|         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.76k|   }
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|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.76k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.76k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.74k, False: 5.02k]
  ------------------
  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|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.74k, False: 5.02k]
  ------------------
  157|  1.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.74k|         }
  159|  5.02k|         else {
  160|  5.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.02k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_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|  6.76k|      {
   73|  6.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|  6.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_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|  6.76k|      {
   44|  6.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201, False: 6.56k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    201|            else if constexpr( has_apply0_bool ) {
  153|    201|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    201|            }
  155|    201|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201, False: 6.56k]
  ------------------
  157|    201|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    201|         }
  159|  6.56k|         else {
  160|  6.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.56k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.76k|      {
   59|  6.76k|         return Rule::match( in );
   60|  6.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.56k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.56k|      else {
  108|  6.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 483, False: 6.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|    483|            else if constexpr( has_apply0_bool ) {
  153|    483|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    483|            }
  155|    483|         }
  156|  6.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 483, False: 6.07k]
  ------------------
  157|    483|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    483|         }
  159|  6.07k|         else {
  160|  6.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.07k|         }
  162|  6.56k|         (void)m( result );
  163|  6.56k|         return result;
  164|  6.56k|      }
  165|  6.56k|   }
_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|  6.56k|      {
   73|  6.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|  6.56k|         else {
   84|  6.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.56k|      }
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|  6.56k|      {
   59|  6.56k|         return Rule::match( in );
   60|  6.56k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.07k|      else {
  108|  6.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 198, False: 5.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  6.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 198, False: 5.88k]
  ------------------
  157|    198|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    198|         }
  159|  5.88k|         else {
  160|  5.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.88k|         }
  162|  6.07k|         (void)m( result );
  163|  6.07k|         return result;
  164|  6.07k|      }
  165|  6.07k|   }
_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.07k|      {
   73|  6.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|  6.07k|         else {
   84|  6.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.07k|      }
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.07k|      {
   59|  6.07k|         return Rule::match( in );
   60|  6.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.88k|      else {
  108|  5.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 345, False: 5.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    345|            else if constexpr( has_apply0_bool ) {
  153|    345|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    345|            }
  155|    345|         }
  156|  5.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 345, False: 5.53k]
  ------------------
  157|    345|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    345|         }
  159|  5.53k|         else {
  160|  5.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.53k|         }
  162|  5.88k|         (void)m( result );
  163|  5.88k|         return result;
  164|  5.88k|      }
  165|  5.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.88k|      {
   73|  5.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.88k|         else {
   84|  5.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.88k|      {
   59|  5.88k|         return Rule::match( in );
   60|  5.88k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.53k|      else {
  108|  5.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 265, False: 5.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|    265|            else if constexpr( has_apply0_bool ) {
  153|    265|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    265|            }
  155|    265|         }
  156|  5.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 265, False: 5.27k]
  ------------------
  157|    265|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    265|         }
  159|  5.27k|         else {
  160|  5.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.27k|         }
  162|  5.53k|         (void)m( result );
  163|  5.53k|         return result;
  164|  5.53k|      }
  165|  5.53k|   }
_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.53k|      {
   73|  5.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.53k|         else {
   84|  5.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.53k|      }
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.53k|      {
   59|  5.53k|         return Rule::match( in );
   60|  5.53k|      }
_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.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.27k|      else {
  108|  5.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 248, False: 5.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|    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|  5.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 248, False: 5.02k]
  ------------------
  157|    248|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    248|         }
  159|  5.02k|         else {
  160|  5.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.02k|         }
  162|  5.27k|         (void)m( result );
  163|  5.27k|         return result;
  164|  5.27k|      }
  165|  5.27k|   }
_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.27k|      {
   73|  5.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.27k|         else {
   84|  5.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.27k|      }
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.27k|      {
   59|  5.27k|         return Rule::match( in );
   60|  5.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76k|      else {
  108|  6.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.22k, False: 2.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.22k|            else if constexpr( has_apply0_bool ) {
  153|  4.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.22k|            }
  155|  4.22k|         }
  156|  6.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.22k, False: 2.53k]
  ------------------
  157|  4.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.22k|         }
  159|  2.53k|         else {
  160|  2.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.53k|         }
  162|  6.76k|         (void)m( result );
  163|  6.76k|         return result;
  164|  6.76k|      }
  165|  6.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.76k|      {
   73|  6.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76k|         else {
   84|  6.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.76k|      {
   59|  6.76k|         return Rule::match( in );
   60|  6.76k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.20k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.20k|      else {
  108|  7.20k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.20k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.20k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.20k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.20k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.20k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.20k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.20k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.20k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.20k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.20k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.20k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.20k, 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.20k|            else if constexpr( has_apply0_bool ) {
  153|  7.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.20k|            }
  155|  7.20k|         }
  156|  7.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.20k, False: 0]
  ------------------
  157|  7.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.20k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  7.20k|         (void)m( result );
  163|  7.20k|         return result;
  164|  7.20k|      }
  165|  7.20k|   }
_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|  7.20k|      {
   73|  7.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|  7.20k|         else {
   84|  7.20k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.20k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.20k|      }
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|  7.20k|      {
   44|  7.20k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.20k|      }
_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.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.97k, False: 1.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.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|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.97k, False: 1.25k]
  ------------------
  157|  2.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.97k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_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.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_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.09k|   {
  104|  4.09k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.09k|         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.09k|   }
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.09k|      {
   44|  4.09k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.09k|      }
_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|   803k|   {
  104|   803k|      if constexpr( !Control< Rule >::enable ) {
  105|   803k|         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|   803k|   }
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|   803k|      {
   44|   803k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   803k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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: 2.34k, False: 629]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.34k|            else if constexpr( has_apply0_bool ) {
  153|  2.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.34k|            }
  155|  2.34k|         }
  156|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.34k, False: 629]
  ------------------
  157|  2.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.34k|         }
  159|    629|         else {
  160|    629|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    629|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = 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|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 808k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 808k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 806k, False: 1.59k]
  ------------------
  143|   806k|            if constexpr( has_apply_void ) {
  144|   806k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   806k|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 805k, False: 3.50k]
  ------------------
  157|   805k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   805k|         }
  159|  3.50k|         else {
  160|  3.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.50k|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   44|   808k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   808k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 808k, 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|   808k|            else if constexpr( has_apply0_bool ) {
  153|   808k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   808k|            }
  155|   808k|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 808k, False: 0]
  ------------------
  157|   808k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   808k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_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|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   44|   808k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   808k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 318, False: 808k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    318|            else if constexpr( has_apply0_bool ) {
  153|    318|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    318|            }
  155|    318|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 318, False: 808k]
  ------------------
  157|    318|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    318|         }
  159|   808k|         else {
  160|   808k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   808k|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   59|   808k|         return Rule::match( in );
   60|   808k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 807k, False: 1.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   807k|            else if constexpr( has_apply0_bool ) {
  153|   807k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   807k|            }
  155|   807k|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 807k, False: 1.19k]
  ------------------
  157|   807k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   807k|         }
  159|  1.19k|         else {
  160|  1.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.19k|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_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|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   44|   808k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   808k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   808k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   808k|      else {
  108|   808k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   808k|         using iterator_t = typename ParseInput::iterator_t;
  111|   808k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   808k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   808k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   808k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   808k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   808k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   808k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   808k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   808k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   808k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   808k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   808k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   808k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   808k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   808k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   808k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   808k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   808k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 807k, False: 1.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   807k|            else if constexpr( has_apply0_bool ) {
  153|   807k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   807k|            }
  155|   807k|         }
  156|   808k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 807k, False: 1.19k]
  ------------------
  157|   807k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   807k|         }
  159|  1.19k|         else {
  160|  1.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.19k|         }
  162|   808k|         (void)m( result );
  163|   808k|         return result;
  164|   808k|      }
  165|   808k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   808k|      {
   73|   808k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   808k|         else {
   84|   808k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   808k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   808k|      }
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|   808k|      {
   59|   808k|         return Rule::match( in );
   60|   808k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   807k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   807k|      else {
  108|   807k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   807k|         using iterator_t = typename ParseInput::iterator_t;
  111|   807k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   807k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   807k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   807k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   807k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   807k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   807k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   807k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   807k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   807k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   807k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   807k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   807k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   807k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   807k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   807k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   807k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   807k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 807k, 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|   807k|            else if constexpr( has_apply0_bool ) {
  153|   807k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   807k|            }
  155|   807k|         }
  156|   807k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 807k, False: 0]
  ------------------
  157|   807k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   807k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   807k|         (void)m( result );
  163|   807k|         return result;
  164|   807k|      }
  165|   807k|   }
_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|   807k|      {
   73|   807k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   807k|         else {
   84|   807k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   807k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   807k|      }
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|   807k|      {
   44|   807k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   807k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  26.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.6M|      else {
  108|  26.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.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|  26.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|  26.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|  26.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|  26.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.8M, False: 807k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.8M|            else if constexpr( has_apply0_bool ) {
  153|  25.8M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.8M|            }
  155|  25.8M|         }
  156|  26.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.8M, False: 807k]
  ------------------
  157|  25.8M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.8M|         }
  159|   807k|         else {
  160|   807k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   807k|         }
  162|  26.6M|         (void)m( result );
  163|  26.6M|         return result;
  164|  26.6M|      }
  165|  26.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  26.6M|      {
   73|  26.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|  26.6M|         else {
   84|  26.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.6M|      }
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|  26.6M|      {
   59|  26.6M|         return Rule::match( in );
   60|  26.6M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   807k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   807k|      else {
  108|   807k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   807k|         using iterator_t = typename ParseInput::iterator_t;
  111|   807k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   807k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   807k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   807k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   807k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   807k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   807k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   807k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   807k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   807k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   807k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   807k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   807k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   807k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   807k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   807k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   807k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   807k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 806k, False: 400]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   806k|            else if constexpr( has_apply0_bool ) {
  153|   806k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   806k|            }
  155|   806k|         }
  156|   807k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 806k, False: 400]
  ------------------
  157|   806k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   806k|         }
  159|    400|         else {
  160|    400|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    400|         }
  162|   807k|         (void)m( result );
  163|   807k|         return result;
  164|   807k|      }
  165|   807k|   }
_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|   807k|      {
   73|   807k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   807k|         else {
   84|   807k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   807k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   807k|      }
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|   807k|      {
   44|   807k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   807k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   807k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   807k|      else {
  108|   807k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   807k|         using iterator_t = typename ParseInput::iterator_t;
  111|   807k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   807k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   807k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   807k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   807k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   807k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   807k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   807k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   807k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   807k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   807k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   807k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   807k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   807k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   807k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   807k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   807k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   807k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.6k, False: 766k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.6k|            else if constexpr( has_apply0_bool ) {
  153|  40.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.6k|            }
  155|  40.6k|         }
  156|   807k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.6k, False: 766k]
  ------------------
  157|  40.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.6k|         }
  159|   766k|         else {
  160|   766k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   766k|         }
  162|   807k|         (void)m( result );
  163|   807k|         return result;
  164|   807k|      }
  165|   807k|   }
_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|   807k|      {
   73|   807k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   807k|         else {
   84|   807k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   807k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   807k|      }
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|   807k|      {
   44|   807k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   807k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   807k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   807k|      else {
  108|   807k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   807k|         using iterator_t = typename ParseInput::iterator_t;
  111|   807k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   807k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   807k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   807k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   807k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   807k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   807k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   807k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   807k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   807k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   807k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   807k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   807k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   807k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   807k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   807k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   807k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   807k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.0k, False: 766k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.0k|            else if constexpr( has_apply0_bool ) {
  153|  41.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.0k|            }
  155|  41.0k|         }
  156|   807k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.0k, False: 766k]
  ------------------
  157|  41.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.0k|         }
  159|   766k|         else {
  160|   766k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   766k|         }
  162|   807k|         (void)m( result );
  163|   807k|         return result;
  164|   807k|      }
  165|   807k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   807k|      {
   73|   807k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   807k|         else {
   84|   807k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   807k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   807k|      }
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|   807k|      {
   59|   807k|         return Rule::match( in );
   60|   807k|      }
_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|  41.0k|   {
  104|  41.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  41.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|  41.0k|   }
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|  41.0k|      {
   44|  41.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.0k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  41.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.0k|      else {
  108|  41.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.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|  41.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|  41.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|  41.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|  41.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|  41.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|  41.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.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|  41.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.6k, False: 400]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.6k|            else if constexpr( has_apply0_bool ) {
  153|  40.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.6k|            }
  155|  40.6k|         }
  156|  41.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.6k, False: 400]
  ------------------
  157|  40.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.6k|         }
  159|    400|         else {
  160|    400|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    400|         }
  162|  41.0k|         (void)m( result );
  163|  41.0k|         return result;
  164|  41.0k|      }
  165|  41.0k|   }
_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|  41.0k|      {
   73|  41.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|  41.0k|         else {
   84|  41.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.0k|      }
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|  41.0k|      {
   44|  41.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  53.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.3M|      else {
  108|  53.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.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|  53.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|  53.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|  53.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|  53.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|  53.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|  53.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.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|  53.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.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|  53.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.6k, False: 53.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|  40.6k|            else if constexpr( has_apply0_bool ) {
  153|  40.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.6k|            }
  155|  40.6k|         }
  156|  53.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.6k, False: 53.2M]
  ------------------
  157|  40.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.6k|         }
  159|  53.2M|         else {
  160|  53.2M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  53.2M|         }
  162|  53.3M|         (void)m( result );
  163|  53.3M|         return result;
  164|  53.3M|      }
  165|  53.3M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  53.3M|      {
   73|  53.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|  53.3M|         else {
   84|  53.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.3M|      }
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|  53.3M|      {
   59|  53.3M|         return Rule::match( in );
   60|  53.3M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  53.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.2M|      else {
  108|  53.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.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|  53.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|  53.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|  53.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|  53.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|  53.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|  53.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.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|  53.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.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|  53.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.2M, False: 400]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.2M|            else if constexpr( has_apply0_bool ) {
  153|  53.2M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.2M|            }
  155|  53.2M|         }
  156|  53.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.2M, False: 400]
  ------------------
  157|  53.2M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.2M|         }
  159|    400|         else {
  160|    400|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    400|         }
  162|  53.2M|         (void)m( result );
  163|  53.2M|         return result;
  164|  53.2M|      }
  165|  53.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  53.2M|      {
   73|  53.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|  53.2M|         else {
   84|  53.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.2M|      }
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|  53.2M|      {
   44|  53.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  53.2M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  53.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.2M|      else {
  108|  53.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.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|  53.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|  53.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|  53.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|  53.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|  53.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|  53.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.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|  53.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.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|  53.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 162k, False: 53.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   162k|            else if constexpr( has_apply0_bool ) {
  153|   162k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   162k|            }
  155|   162k|         }
  156|  53.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 162k, False: 53.1M]
  ------------------
  157|   162k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   162k|         }
  159|  53.1M|         else {
  160|  53.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  53.1M|         }
  162|  53.2M|         (void)m( result );
  163|  53.2M|         return result;
  164|  53.2M|      }
  165|  53.2M|   }
_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|  53.2M|      {
   73|  53.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|  53.2M|         else {
   84|  53.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.2M|      }
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|  53.2M|      {
   44|  53.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  53.2M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  53.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.2M|      else {
  108|  53.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.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|  53.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|  53.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|  53.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|  53.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|  53.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|  53.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.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|  53.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.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|  53.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 53.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   163k|            else if constexpr( has_apply0_bool ) {
  153|   163k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   163k|            }
  155|   163k|         }
  156|  53.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 53.1M]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  53.1M|         else {
  160|  53.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  53.1M|         }
  162|  53.2M|         (void)m( result );
  163|  53.2M|         return result;
  164|  53.2M|      }
  165|  53.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  53.2M|      {
   73|  53.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|  53.2M|         else {
   84|  53.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.2M|      }
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|  53.2M|      {
   59|  53.2M|         return Rule::match( in );
   60|  53.2M|      }
_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|   163k|   {
  104|   163k|      if constexpr( !Control< Rule >::enable ) {
  105|   163k|         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|   163k|   }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_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|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 162k, 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|   162k|            else if constexpr( has_apply0_bool ) {
  153|   162k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   162k|            }
  155|   162k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 162k, False: 111]
  ------------------
  157|   162k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   162k|         }
  159|    111|         else {
  160|    111|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    111|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_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|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 51.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|  51.4k|            else if constexpr( has_apply0_bool ) {
  153|  51.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  51.4k|            }
  155|  51.4k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 51.4k, False: 111k]
  ------------------
  157|  51.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  51.4k|         }
  159|   111k|         else {
  160|   111k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   111k|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_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|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 51.5k, 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|  51.5k|            else if constexpr( has_apply0_bool ) {
  153|  51.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  51.5k|            }
  155|  51.5k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 51.5k, False: 111k]
  ------------------
  157|  51.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  51.5k|         }
  159|   111k|         else {
  160|   111k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   111k|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   59|   163k|         return Rule::match( in );
   60|   163k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  51.5k|   {
  104|  51.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  51.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|  51.5k|   }
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|  51.5k|      {
   44|  51.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  51.5k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  51.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  51.5k|      else {
  108|  51.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  51.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  51.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|  51.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|  51.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|  51.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|  51.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|  51.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|  51.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  51.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  51.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  51.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|  51.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  51.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  51.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|  51.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  51.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  51.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  51.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  51.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 51.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|  51.4k|            else if constexpr( has_apply0_bool ) {
  153|  51.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  51.4k|            }
  155|  51.4k|         }
  156|  51.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 51.4k, False: 45]
  ------------------
  157|  51.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  51.4k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  51.5k|         (void)m( result );
  163|  51.5k|         return result;
  164|  51.5k|      }
  165|  51.5k|   }
_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|  51.5k|      {
   73|  51.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|  51.5k|         else {
   84|  51.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  51.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  51.5k|      }
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|  51.5k|      {
   44|  51.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  51.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   102k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   102k|      else {
  108|   102k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   102k|         using iterator_t = typename ParseInput::iterator_t;
  111|   102k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   102k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   102k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   102k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   102k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   102k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   102k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   102k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   102k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   102k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   102k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   102k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   102k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   102k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   102k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   102k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   102k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   102k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 102k, 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|   102k|            else if constexpr( has_apply0_bool ) {
  153|   102k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   102k|            }
  155|   102k|         }
  156|   102k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 102k, False: 45]
  ------------------
  157|   102k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   102k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|   102k|         (void)m( result );
  163|   102k|         return result;
  164|   102k|      }
  165|   102k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   102k|      {
   73|   102k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   102k|         else {
   84|   102k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   102k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   102k|      }
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|   102k|      {
   59|   102k|         return Rule::match( in );
   60|   102k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   111k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   111k|      else {
  108|   111k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   111k|         using iterator_t = typename ParseInput::iterator_t;
  111|   111k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   111k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   111k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   111k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   111k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   111k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   111k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   111k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   111k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   111k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   111k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   111k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   111k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   111k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   111k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   111k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   111k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   111k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.3k, False: 85.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|  26.3k|            else if constexpr( has_apply0_bool ) {
  153|  26.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.3k|            }
  155|  26.3k|         }
  156|   111k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.3k, False: 85.2k]
  ------------------
  157|  26.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.3k|         }
  159|  85.2k|         else {
  160|  85.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  85.2k|         }
  162|   111k|         (void)m( result );
  163|   111k|         return result;
  164|   111k|      }
  165|   111k|   }
_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|   111k|      {
   73|   111k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   111k|         else {
   84|   111k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   111k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   111k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   111k|      {
   44|   111k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   111k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   142k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   142k|      else {
  108|   142k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   142k|         using iterator_t = typename ParseInput::iterator_t;
  111|   142k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   142k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   142k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   142k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   142k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   142k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   142k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   142k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   142k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   142k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   142k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   142k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   142k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   142k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   142k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   142k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   142k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   142k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.7k, False: 109k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.7k|            else if constexpr( has_apply0_bool ) {
  153|  33.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.7k|            }
  155|  33.7k|         }
  156|   142k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.7k, False: 109k]
  ------------------
  157|  33.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.7k|         }
  159|   109k|         else {
  160|   109k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   109k|         }
  162|   142k|         (void)m( result );
  163|   142k|         return result;
  164|   142k|      }
  165|   142k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   142k|      {
   73|   142k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   142k|         else {
   84|   142k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   142k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   142k|      }
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|   142k|      {
   59|   142k|         return Rule::match( in );
   60|   142k|      }
_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|  26.3k|   {
  104|  26.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  26.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|  26.3k|   }
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|  26.3k|      {
   44|  26.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.3k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  26.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.3k|      else {
  108|  26.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.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|  26.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|  26.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|  26.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|  26.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.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|  26.3k|            else if constexpr( has_apply0_bool ) {
  153|  26.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.3k|            }
  155|  26.3k|         }
  156|  26.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.3k, False: 0]
  ------------------
  157|  26.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  26.3k|         (void)m( result );
  163|  26.3k|         return result;
  164|  26.3k|      }
  165|  26.3k|   }
_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|  26.3k|      {
   73|  26.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|  26.3k|         else {
   84|  26.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.3k|      }
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|  26.3k|      {
   44|  26.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  85.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  85.2k|      else {
  108|  85.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.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|  85.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|  85.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|  85.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|  85.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|  85.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|  85.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.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|  85.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.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|  85.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  85.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 84.7k, False: 422]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  84.7k|            else if constexpr( has_apply0_bool ) {
  153|  84.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  84.7k|            }
  155|  84.7k|         }
  156|  85.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 84.7k, False: 422]
  ------------------
  157|  84.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  84.7k|         }
  159|    422|         else {
  160|    422|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    422|         }
  162|  85.2k|         (void)m( result );
  163|  85.2k|         return result;
  164|  85.2k|      }
  165|  85.2k|   }
_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|  85.2k|      {
   73|  85.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|  85.2k|         else {
   84|  85.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.2k|      }
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|  85.2k|      {
   59|  85.2k|         return Rule::match( in );
   60|  85.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    422|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    422|      else {
  108|    422|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    422|         using iterator_t = typename ParseInput::iterator_t;
  111|    422|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    422|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    422|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    422|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    422|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    422|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    422|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    422|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    422|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    422|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    422|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    422|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    422|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    422|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    422|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    422|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    422|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    422|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 356, False: 66]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    356|            else if constexpr( has_apply0_bool ) {
  153|    356|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    356|            }
  155|    356|         }
  156|    422|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 356, False: 66]
  ------------------
  157|    356|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    356|         }
  159|     66|         else {
  160|     66|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     66|         }
  162|    422|         (void)m( result );
  163|    422|         return result;
  164|    422|      }
  165|    422|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    422|      {
   73|    422|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    422|         else {
   84|    422|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    422|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    422|      }
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|    422|      {
   59|    422|         return Rule::match( in );
   60|    422|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  53.1M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.1M|      else {
  108|  53.1M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.1M|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.1M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  53.1M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  53.1M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  53.1M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  53.1M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  53.1M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  53.1M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.1M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.1M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.1M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  53.1M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.1M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.1M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  53.1M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.1M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.1M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.1M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.1M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.1M, False: 289]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.1M|            else if constexpr( has_apply0_bool ) {
  153|  53.1M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.1M|            }
  155|  53.1M|         }
  156|  53.1M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.1M, False: 289]
  ------------------
  157|  53.1M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.1M|         }
  159|    289|         else {
  160|    289|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    289|         }
  162|  53.1M|         (void)m( result );
  163|  53.1M|         return result;
  164|  53.1M|      }
  165|  53.1M|   }
_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|  53.1M|      {
   73|  53.1M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  53.1M|         else {
   84|  53.1M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.1M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.1M|      }
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|  53.1M|      {
   59|  53.1M|         return Rule::match( in );
   60|  53.1M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  12.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.6k|      else {
  108|  12.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.34k, False: 9.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|  3.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  12.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 9.31k]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|  9.31k|         else {
  160|  9.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.31k|         }
  162|  12.6k|         (void)m( result );
  163|  12.6k|         return result;
  164|  12.6k|      }
  165|  12.6k|   }
_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|  12.6k|      {
   73|  12.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|  12.6k|         else {
   84|  12.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6k|      }
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|  12.6k|      {
   44|  12.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  12.6k|      }
_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|  12.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.6k|      else {
  108|  12.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.34k, False: 9.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|  3.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  12.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 9.31k]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|  9.31k|         else {
  160|  9.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.31k|         }
  162|  12.6k|         (void)m( result );
  163|  12.6k|         return result;
  164|  12.6k|      }
  165|  12.6k|   }
_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|  12.6k|      {
   73|  12.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|  12.6k|         else {
   84|  12.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6k|      }
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|  12.6k|      {
   44|  12.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  12.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  12.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  12.6k|      else {
  108|  12.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  12.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  12.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|  12.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|  12.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|  12.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|  12.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|  12.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|  12.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  12.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  12.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  12.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|  12.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  12.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  12.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|  12.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  12.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  12.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  12.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  12.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.05k, 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|  4.05k|            else if constexpr( has_apply0_bool ) {
  153|  4.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.05k|            }
  155|  4.05k|         }
  156|  12.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.05k, False: 8.60k]
  ------------------
  157|  4.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.05k|         }
  159|  8.60k|         else {
  160|  8.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.60k|         }
  162|  12.6k|         (void)m( result );
  163|  12.6k|         return result;
  164|  12.6k|      }
  165|  12.6k|   }
_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|  12.6k|      {
   73|  12.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|  12.6k|         else {
   84|  12.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  12.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  12.6k|      }
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|  12.6k|      {
   59|  12.6k|         return Rule::match( in );
   60|  12.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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: 8.48k, 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|  8.48k|            else if constexpr( has_apply0_bool ) {
  153|  8.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.48k|            }
  155|  8.48k|         }
  156|  10.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.48k, False: 1.70k]
  ------------------
  157|  8.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.48k|         }
  159|  1.70k|         else {
  160|  1.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70k|         }
  162|  10.1k|         (void)m( result );
  163|  10.1k|         return result;
  164|  10.1k|      }
  165|  10.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.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_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.1k|      {
   44|  10.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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: 8.48k, 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|  8.48k|            else if constexpr( has_apply0_bool ) {
  153|  8.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.48k|            }
  155|  8.48k|         }
  156|  10.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.48k, False: 1.70k]
  ------------------
  157|  8.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.48k|         }
  159|  1.70k|         else {
  160|  1.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70k|         }
  162|  10.1k|         (void)m( result );
  163|  10.1k|         return result;
  164|  10.1k|      }
  165|  10.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.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_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.1k|      {
   59|  10.1k|         return Rule::match( in );
   60|  10.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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: 3.41k, False: 12.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|  3.41k|            else if constexpr( has_apply0_bool ) {
  153|  3.41k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.41k|            }
  155|  3.41k|         }
  156|  16.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.41k, False: 12.8k]
  ------------------
  157|  3.41k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.41k|         }
  159|  12.8k|         else {
  160|  12.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.8k|         }
  162|  16.2k|         (void)m( result );
  163|  16.2k|         return result;
  164|  16.2k|      }
  165|  16.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  16.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_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.2k|      {
   59|  16.2k|         return Rule::match( in );
   60|  16.2k|      }
_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.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: 3.34k, False: 689]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 689]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|    689|         else {
  160|    689|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    689|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_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.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: 2.00k, 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|  2.00k|            else if constexpr( has_apply0_bool ) {
  153|  2.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.00k|            }
  155|  2.00k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.00k, False: 2.03k]
  ------------------
  157|  2.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.00k|         }
  159|  2.03k|         else {
  160|  2.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.03k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_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.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: 4.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|  4.03k|            else if constexpr( has_apply0_bool ) {
  153|  4.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.03k|            }
  155|  4.03k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.03k, False: 0]
  ------------------
  157|  4.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.03k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_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.03k|   {
  104|  4.03k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.03k|   }
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.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_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): [True: 0, Folded]
  ------------------
  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): [True: 4.03k, Folded]
  |  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): [True: 4.03k, Folded]
  |  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: 1.26k, False: 2.76k]
  ------------------
  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|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.26k, False: 2.76k]
  ------------------
  157|  1.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.26k|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_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.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: 217, False: 3.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    217|            else if constexpr( has_apply0_bool ) {
  153|    217|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    217|            }
  155|    217|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 217, False: 3.81k]
  ------------------
  157|    217|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    217|         }
  159|  3.81k|         else {
  160|  3.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.81k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   59|  4.03k|         return Rule::match( in );
   60|  4.03k|      }
_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.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.81k|      else {
  108|  3.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 116, False: 3.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|    116|            else if constexpr( has_apply0_bool ) {
  153|    116|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    116|            }
  155|    116|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 116, False: 3.70k]
  ------------------
  157|    116|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    116|         }
  159|  3.70k|         else {
  160|  3.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.70k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.81k|      {
   73|  3.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.81k|         else {
   84|  3.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.81k|      }
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.81k|      {
   59|  3.81k|         return Rule::match( in );
   60|  3.81k|      }
_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.70k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.70k|      else {
  108|  3.70k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.70k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.70k|         constexpr bool has_apply_void = enable_action && internal::has_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.70k|         constexpr bool has_apply_bool = enable_action && internal::has_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.70k|         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.70k|         constexpr bool has_apply0_void = enable_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.70k|         constexpr bool has_apply0_bool = enable_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.70k|         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.70k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.70k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.70k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.70k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.70k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.70k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.70k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.70k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.70k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.70k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.70k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.70k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 209, False: 3.49k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    209|            else if constexpr( has_apply0_bool ) {
  153|    209|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    209|            }
  155|    209|         }
  156|  3.70k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 209, False: 3.49k]
  ------------------
  157|    209|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    209|         }
  159|  3.49k|         else {
  160|  3.49k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.49k|         }
  162|  3.70k|         (void)m( result );
  163|  3.70k|         return result;
  164|  3.70k|      }
  165|  3.70k|   }
_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.70k|      {
   73|  3.70k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.70k|         else {
   84|  3.70k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.70k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.70k|      }
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.70k|      {
   59|  3.70k|         return Rule::match( in );
   60|  3.70k|      }
_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.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.49k|      else {
  108|  3.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.49k|         constexpr bool has_apply_void = enable_action && internal::has_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.49k|         constexpr bool has_apply_bool = enable_action && internal::has_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.49k|         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.49k|         constexpr bool has_apply0_void = enable_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.49k|         constexpr bool has_apply0_bool = enable_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.49k|         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.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.49k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.49k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 3.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|    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.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.30k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.30k|         else {
  160|  3.30k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.30k|         }
  162|  3.49k|         (void)m( result );
  163|  3.49k|         return result;
  164|  3.49k|      }
  165|  3.49k|   }
_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.49k|      {
   73|  3.49k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.49k|         else {
   84|  3.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.49k|      }
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.49k|      {
   59|  3.49k|         return Rule::match( in );
   60|  3.49k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.30k|      else {
  108|  3.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 287, 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|    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|  3.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 287, False: 3.01k]
  ------------------
  157|    287|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    287|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  3.30k|         (void)m( result );
  163|  3.30k|         return result;
  164|  3.30k|      }
  165|  3.30k|   }
_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.30k|      {
   73|  3.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|  3.30k|         else {
   84|  3.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.30k|      }
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.30k|      {
   59|  3.30k|         return Rule::match( in );
   60|  3.30k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.01k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.01k|      else {
  108|  3.01k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.01k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.01k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.01k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.01k|         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.01k|         constexpr bool has_apply0_void = enable_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.01k|         constexpr bool has_apply0_bool = enable_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.01k|         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.01k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.01k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.01k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.01k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.01k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.01k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.01k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.01k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.01k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.01k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.01k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.01k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 246, 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|    246|            else if constexpr( has_apply0_bool ) {
  153|    246|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    246|            }
  155|    246|         }
  156|  3.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 246, False: 2.76k]
  ------------------
  157|    246|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    246|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_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|  3.01k|      {
   73|  3.01k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.01k|         else {
   84|  3.01k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.01k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.01k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.01k|      {
   59|  3.01k|         return Rule::match( in );
   60|  3.01k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 2.22k, False: 1.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.22k|            else if constexpr( has_apply0_bool ) {
  153|  2.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.22k|            }
  155|  2.22k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.22k, False: 1.81k]
  ------------------
  157|  2.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.22k|         }
  159|  1.81k|         else {
  160|  1.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.81k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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.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_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.03k|      {
   59|  4.03k|         return Rule::match( in );
   60|  4.03k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.36k|      else {
  108|  4.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, 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.36k|            else if constexpr( has_apply0_bool ) {
  153|  4.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.36k|            }
  155|  4.36k|         }
  156|  4.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.36k, False: 0]
  ------------------
  157|  4.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.36k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.36k|         (void)m( result );
  163|  4.36k|         return result;
  164|  4.36k|      }
  165|  4.36k|   }
_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.36k|      {
   73|  4.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|  4.36k|         else {
   84|  4.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.36k|      }
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.36k|      {
   44|  4.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.36k|      }
_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.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.22k|      else {
  108|  2.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.22k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.14k, 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|  2.14k|            else if constexpr( has_apply0_bool ) {
  153|  2.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.14k|            }
  155|  2.14k|         }
  156|  2.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.14k, False: 79]
  ------------------
  157|  2.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.14k|         }
  159|     79|         else {
  160|     79|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     79|         }
  162|  2.22k|         (void)m( result );
  163|  2.22k|         return result;
  164|  2.22k|      }
  165|  2.22k|   }
_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.22k|      {
   73|  2.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.22k|         else {
   84|  2.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.22k|      }
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.22k|      {
   44|  2.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.22k|      }
_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.15k|   {
  104|  2.15k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.15k|         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.15k|   }
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.15k|      {
   44|  2.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.15k|      }
_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.85k|   {
  104|  4.85k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.85k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.85k|   }
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.85k|      {
   44|  4.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.85k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.14k|      else {
  108|  2.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.14k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.14k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.14k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.14k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.14k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.14k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.14k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.00k, False: 136]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.00k|            else if constexpr( has_apply0_bool ) {
  153|  2.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.00k|            }
  155|  2.00k|         }
  156|  2.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.00k, False: 136]
  ------------------
  157|  2.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.00k|         }
  159|    136|         else {
  160|    136|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    136|         }
  162|  2.14k|         (void)m( result );
  163|  2.14k|         return result;
  164|  2.14k|      }
  165|  2.14k|   }
_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.14k|      {
   73|  2.14k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.14k|         else {
   84|  2.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.14k|      }
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.14k|      {
   59|  2.14k|         return Rule::match( in );
   60|  2.14k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.44k|      else {
  108|  7.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.44k|         constexpr bool has_apply_void = 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.44k|         constexpr bool has_apply_bool = enable_action && internal::has_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.44k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.44k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.44k|         constexpr bool has_apply0_void = enable_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.44k|         constexpr bool has_apply0_bool = enable_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.44k|         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.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.44k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.24k, False: 1.20k]
  ------------------
  143|  6.24k|            if constexpr( has_apply_void ) {
  144|  6.24k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.24k|         }
  156|  7.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.19k, False: 1.25k]
  ------------------
  157|  6.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.19k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|  7.44k|         (void)m( result );
  163|  7.44k|         return result;
  164|  7.44k|      }
  165|  7.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.44k|      {
   73|  7.44k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.44k|         else {
   84|  7.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.44k|      {
   44|  7.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.44k|      else {
  108|  7.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.44k|         constexpr bool has_apply_void = enable_action && internal::has_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.44k|         constexpr bool has_apply_bool = enable_action && internal::has_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.44k|         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.44k|         constexpr bool has_apply0_void = enable_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.44k|         constexpr bool has_apply0_bool = enable_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.44k|         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.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.44k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.44k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.53k, False: 917]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.53k|            else if constexpr( has_apply0_bool ) {
  153|  6.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.53k|            }
  155|  6.53k|         }
  156|  7.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.53k, False: 917]
  ------------------
  157|  6.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.53k|         }
  159|    917|         else {
  160|    917|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    917|         }
  162|  7.44k|         (void)m( result );
  163|  7.44k|         return result;
  164|  7.44k|      }
  165|  7.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.44k|      {
   73|  7.44k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.44k|         else {
   84|  7.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.44k|      {
   59|  7.44k|         return Rule::match( in );
   60|  7.44k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.53k|   {
  104|  6.53k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  6.53k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.53k|      {
   44|  6.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.53k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.53k|      else {
  108|  6.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.53k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.24k, 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|  6.24k|            else if constexpr( has_apply0_bool ) {
  153|  6.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.24k|            }
  155|  6.24k|         }
  156|  6.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.24k, False: 288]
  ------------------
  157|  6.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.24k|         }
  159|    288|         else {
  160|    288|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    288|         }
  162|  6.53k|         (void)m( result );
  163|  6.53k|         return result;
  164|  6.53k|      }
  165|  6.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.53k|      {
   73|  6.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.53k|         else {
   84|  6.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.53k|      {
   44|  6.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.53k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.60M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.60M|      else {
  108|  8.60M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.60M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.60M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.60M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.60M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.60M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.60M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.60M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.60M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.60M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.60M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.60M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.24k, False: 8.59M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  6.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.24k|            }
  155|  6.24k|         }
  156|  8.60M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.24k, False: 8.59M]
  ------------------
  157|  6.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.24k|         }
  159|  8.59M|         else {
  160|  8.59M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.59M|         }
  162|  8.60M|         (void)m( result );
  163|  8.60M|         return result;
  164|  8.60M|      }
  165|  8.60M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.60M|      {
   73|  8.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|  8.60M|         else {
   84|  8.60M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.60M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.60M|      }
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|  8.60M|      {
   59|  8.60M|         return Rule::match( in );
   60|  8.60M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.59M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.59M|      else {
  108|  8.59M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.59M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.59M|         constexpr bool has_apply_void = enable_action && internal::has_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.59M|         constexpr bool has_apply_bool = enable_action && internal::has_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.59M|         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.59M|         constexpr bool has_apply0_void = enable_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.59M|         constexpr bool has_apply0_bool = enable_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.59M|         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.59M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.59M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.59M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.59M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.59M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.59M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.59M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.59M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.59M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.59M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.59M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.59M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.59M, 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|  8.59M|            else if constexpr( has_apply0_bool ) {
  153|  8.59M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.59M|            }
  155|  8.59M|         }
  156|  8.59M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.59M, False: 288]
  ------------------
  157|  8.59M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.59M|         }
  159|    288|         else {
  160|    288|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    288|         }
  162|  8.59M|         (void)m( result );
  163|  8.59M|         return result;
  164|  8.59M|      }
  165|  8.59M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.59M|      {
   73|  8.59M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.59M|         else {
   84|  8.59M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.59M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.59M|      }
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|  8.59M|      {
   44|  8.59M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.59M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.59M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.59M|      else {
  108|  8.59M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.59M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.59M|         constexpr bool has_apply_void = enable_action && internal::has_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.59M|         constexpr bool has_apply_bool = enable_action && internal::has_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.59M|         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.59M|         constexpr bool has_apply0_void = enable_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.59M|         constexpr bool has_apply0_bool = enable_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.59M|         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.59M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.59M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.59M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.59M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.59M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.59M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.59M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.59M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.59M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.59M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.59M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.59M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 8.43M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   163k|            else if constexpr( has_apply0_bool ) {
  153|   163k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   163k|            }
  155|   163k|         }
  156|  8.59M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 8.43M]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  8.43M|         else {
  160|  8.43M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.43M|         }
  162|  8.59M|         (void)m( result );
  163|  8.59M|         return result;
  164|  8.59M|      }
  165|  8.59M|   }
_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|  8.59M|      {
   73|  8.59M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.59M|         else {
   84|  8.59M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.59M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.59M|      }
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|  8.59M|      {
   44|  8.59M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.59M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.59M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.59M|      else {
  108|  8.59M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.59M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.59M|         constexpr bool has_apply_void = enable_action && internal::has_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.59M|         constexpr bool has_apply_bool = enable_action && internal::has_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.59M|         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.59M|         constexpr bool has_apply0_void = enable_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.59M|         constexpr bool has_apply0_bool = enable_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.59M|         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.59M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.59M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.59M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.59M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.59M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.59M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.59M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.59M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.59M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.59M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.59M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.59M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 8.43M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   163k|            else if constexpr( has_apply0_bool ) {
  153|   163k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   163k|            }
  155|   163k|         }
  156|  8.59M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 8.43M]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  8.43M|         else {
  160|  8.43M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.43M|         }
  162|  8.59M|         (void)m( result );
  163|  8.59M|         return result;
  164|  8.59M|      }
  165|  8.59M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.59M|      {
   73|  8.59M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.59M|         else {
   84|  8.59M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.59M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.59M|      }
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|  8.59M|      {
   59|  8.59M|         return Rule::match( in );
   60|  8.59M|      }
_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|   163k|   {
  104|   163k|      if constexpr( !Control< Rule >::enable ) {
  105|   163k|         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|   163k|   }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_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|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 101]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   163k|            else if constexpr( has_apply0_bool ) {
  153|   163k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   163k|            }
  155|   163k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 101]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|    101|         else {
  160|    101|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    101|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_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|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.1k, False: 110k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.1k|            else if constexpr( has_apply0_bool ) {
  153|  53.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.1k|            }
  155|  53.1k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.1k, False: 110k]
  ------------------
  157|  53.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.1k|         }
  159|   110k|         else {
  160|   110k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   110k|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_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|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   163k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   163k|      else {
  108|   163k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   163k|         using iterator_t = typename ParseInput::iterator_t;
  111|   163k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   163k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   163k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   163k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   163k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   163k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   163k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   163k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   163k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   163k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   163k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   163k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   163k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   163k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   163k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   163k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   163k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   163k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.1k, False: 110k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.1k|            else if constexpr( has_apply0_bool ) {
  153|  53.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.1k|            }
  155|  53.1k|         }
  156|   163k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.1k, False: 110k]
  ------------------
  157|  53.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.1k|         }
  159|   110k|         else {
  160|   110k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   110k|         }
  162|   163k|         (void)m( result );
  163|   163k|         return result;
  164|   163k|      }
  165|   163k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   163k|      {
   73|   163k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   163k|         else {
   84|   163k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   163k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   163k|      }
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|   163k|      {
   59|   163k|         return Rule::match( in );
   60|   163k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  53.1k|   {
  104|  53.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  53.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|  53.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  53.1k|      {
   44|  53.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  53.1k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  53.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.1k|      else {
  108|  53.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  53.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  53.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  53.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  53.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  53.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  53.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  53.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  53.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.1k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.1k|            else if constexpr( has_apply0_bool ) {
  153|  53.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.1k|            }
  155|  53.1k|         }
  156|  53.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.1k, False: 41]
  ------------------
  157|  53.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.1k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  53.1k|         (void)m( result );
  163|  53.1k|         return result;
  164|  53.1k|      }
  165|  53.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  53.1k|      {
   73|  53.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  53.1k|         else {
   84|  53.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  53.1k|      {
   44|  53.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  53.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   106k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   106k|      else {
  108|   106k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   106k|         using iterator_t = typename ParseInput::iterator_t;
  111|   106k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   106k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   106k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   106k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   106k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   106k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   106k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   106k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   106k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   106k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   106k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   106k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   106k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   106k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   106k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   106k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   106k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   106k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 106k, 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|   106k|            else if constexpr( has_apply0_bool ) {
  153|   106k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   106k|            }
  155|   106k|         }
  156|   106k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 106k, False: 41]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   106k|      {
   73|   106k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   106k|         else {
   84|   106k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   106k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   106k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   106k|      {
   59|   106k|         return Rule::match( in );
   60|   106k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   110k|      else {
  108|   110k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   110k|         using iterator_t = typename ParseInput::iterator_t;
  111|   110k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   110k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   110k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   110k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   110k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   110k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   110k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   110k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   110k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   110k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   110k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   110k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   110k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   110k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   110k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   110k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   110k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   110k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.1k, False: 40.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|  70.1k|            else if constexpr( has_apply0_bool ) {
  153|  70.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.1k|            }
  155|  70.1k|         }
  156|   110k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.1k, False: 40.3k]
  ------------------
  157|  70.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.1k|         }
  159|  40.3k|         else {
  160|  40.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.3k|         }
  162|   110k|         (void)m( result );
  163|   110k|         return result;
  164|   110k|      }
  165|   110k|   }
_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|   110k|      {
   73|   110k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   110k|         else {
   84|   110k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   110k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   110k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_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|   110k|      {
   44|   110k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   110k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   188k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   188k|      else {
  108|   188k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   188k|         using iterator_t = typename ParseInput::iterator_t;
  111|   188k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   188k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   188k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   188k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   188k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   188k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   188k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   188k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   188k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   188k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   188k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   188k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   188k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   188k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   188k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   188k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   188k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   188k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 84.2k, False: 104k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  84.2k|            else if constexpr( has_apply0_bool ) {
  153|  84.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  84.2k|            }
  155|  84.2k|         }
  156|   188k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 84.2k, False: 104k]
  ------------------
  157|  84.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  84.2k|         }
  159|   104k|         else {
  160|   104k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   104k|         }
  162|   188k|         (void)m( result );
  163|   188k|         return result;
  164|   188k|      }
  165|   188k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   188k|      {
   73|   188k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   188k|         else {
   84|   188k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   188k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   188k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   188k|      {
   59|   188k|         return Rule::match( in );
   60|   188k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  70.1k|   {
  104|  70.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  70.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|  70.1k|   }
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|  70.1k|      {
   44|  70.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.1k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  70.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  70.1k|      else {
  108|  70.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.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|  70.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|  70.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|  70.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|  70.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|  70.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|  70.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.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|  70.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.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|  70.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  70.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.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|  70.1k|            else if constexpr( has_apply0_bool ) {
  153|  70.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.1k|            }
  155|  70.1k|         }
  156|  70.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.1k, False: 0]
  ------------------
  157|  70.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  70.1k|         (void)m( result );
  163|  70.1k|         return result;
  164|  70.1k|      }
  165|  70.1k|   }
_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|  70.1k|      {
   73|  70.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|  70.1k|         else {
   84|  70.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.1k|      }
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|  70.1k|      {
   44|  70.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.3k|      else {
  108|  40.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, 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|  39.2k|            else if constexpr( has_apply0_bool ) {
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|  40.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 1.03k]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  40.3k|         (void)m( result );
  163|  40.3k|         return result;
  164|  40.3k|      }
  165|  40.3k|   }
_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|  40.3k|      {
   73|  40.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|  40.3k|         else {
   84|  40.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.3k|      }
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|  40.3k|      {
   59|  40.3k|         return Rule::match( in );
   60|  40.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.03k|      else {
  108|  1.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.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|  1.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|  1.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|  1.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|  1.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 975, 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|    975|            else if constexpr( has_apply0_bool ) {
  153|    975|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    975|            }
  155|    975|         }
  156|  1.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 975, False: 60]
  ------------------
  157|    975|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    975|         }
  159|     60|         else {
  160|     60|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     60|         }
  162|  1.03k|         (void)m( result );
  163|  1.03k|         return result;
  164|  1.03k|      }
  165|  1.03k|   }
_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.03k|      {
   73|  1.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|  1.03k|         else {
   84|  1.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.03k|      {
   59|  1.03k|         return Rule::match( in );
   60|  1.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.43M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.43M|      else {
  108|  8.43M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.43M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.43M|         constexpr bool has_apply_void = enable_action && internal::has_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.43M|         constexpr bool has_apply_bool = enable_action && internal::has_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.43M|         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.43M|         constexpr bool has_apply0_void = enable_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.43M|         constexpr bool has_apply0_bool = enable_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.43M|         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.43M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.43M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.43M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.43M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.43M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.43M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.43M|         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.43M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.43M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.43M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.43M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.43M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.43M, False: 187]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43M|            else if constexpr( has_apply0_bool ) {
  153|  8.43M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.43M|            }
  155|  8.43M|         }
  156|  8.43M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.43M, False: 187]
  ------------------
  157|  8.43M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.43M|         }
  159|    187|         else {
  160|    187|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    187|         }
  162|  8.43M|         (void)m( result );
  163|  8.43M|         return result;
  164|  8.43M|      }
  165|  8.43M|   }
_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|  8.43M|      {
   73|  8.43M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.43M|         else {
   84|  8.43M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.43M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.43M|      }
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|  8.43M|      {
   59|  8.43M|         return Rule::match( in );
   60|  8.43M|      }
_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|  28.6k|   {
  104|  28.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  28.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|  28.6k|   }
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|  28.6k|      {
   44|  28.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.6k|      }
_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|  31.6k|   {
  104|  31.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  31.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|  31.6k|   }
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|  31.6k|      {
   44|  31.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.6k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_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: 37.7k, 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|  37.7k|            else if constexpr( has_apply0_bool ) {
  153|  37.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.7k|            }
  155|  37.7k|         }
  156|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.7k, False: 0]
  ------------------
  157|  37.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_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|  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_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|  37.7k|      {
   44|  37.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.7k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  37.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.9k|      else {
  108|  37.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.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|  37.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|  37.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|  37.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|  37.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.3k, False: 4.58k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  37.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.3k, False: 4.58k]
  ------------------
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|  4.58k|         else {
  160|  4.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.58k|         }
  162|  37.9k|         (void)m( result );
  163|  37.9k|         return result;
  164|  37.9k|      }
  165|  37.9k|   }
_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|  37.9k|      {
   73|  37.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|  37.9k|         else {
   84|  37.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  37.9k|      {
   44|  37.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.9k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  37.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.9k|      else {
  108|  37.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.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|  37.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|  37.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|  37.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|  37.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.3k, False: 4.58k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.3k|            else if constexpr( has_apply0_bool ) {
  153|  33.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.3k|            }
  155|  33.3k|         }
  156|  37.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.3k, False: 4.58k]
  ------------------
  157|  33.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.3k|         }
  159|  4.58k|         else {
  160|  4.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.58k|         }
  162|  37.9k|         (void)m( result );
  163|  37.9k|         return result;
  164|  37.9k|      }
  165|  37.9k|   }
_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|  37.9k|      {
   73|  37.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|  37.9k|         else {
   84|  37.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  37.9k|      {
   59|  37.9k|         return Rule::match( in );
   60|  37.9k|      }

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

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  42.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.5k|         else {
   92|  42.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.5k|         }
   94|  42.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.5k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   160k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   160k|         else {
   92|   160k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   160k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   160k|         }
   94|   160k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   212k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   279k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   279k|         else {
   92|   279k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   279k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   279k|         }
   94|   279k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  6.85M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  4.09M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.76M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   212k|      {}
_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|  42.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.5k|         else {
   92|  42.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.5k|         }
   94|  42.5k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  42.5k|      {}
_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|  42.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.5k|         else {
   92|  42.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.5k|         }
   94|  42.5k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  42.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  80.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|  80.2k|         else {
   92|  80.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  80.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  80.2k|         }
   94|  80.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  80.2k|      {}
_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|  80.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|  80.2k|         else {
   92|  80.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  80.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  80.2k|         }
   94|  80.2k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  80.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  80.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|  80.2k|         else {
   92|  80.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  80.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  80.2k|         }
   94|  80.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  80.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  67.0k|      {}
_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|  13.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|  13.2k|         else {
   92|  13.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2k|         }
   94|  13.2k|      }
_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|  13.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|  13.2k|         else {
   92|  13.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2k|         }
   94|  13.2k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  13.2k|      {}
_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|   834k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   834k|         else {
   92|   834k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   834k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   834k|         }
   94|   834k|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   834k|      {}
_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|   834k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   834k|         else {
   92|   834k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   834k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   834k|         }
   94|   834k|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   834k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|   834k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   834k|         else {
   92|   834k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   834k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   834k|         }
   94|   834k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   872k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  46.5k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   826k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   821k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   821k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   821k|         else {
   92|   821k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   821k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   821k|         }
   94|   821k|      }
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   821k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   821k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   821k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  67.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0ITtTpTyENS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  13.2k|      {
   75|  13.2k|         return Action< Rule >::apply0( st... );
   76|  13.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  13.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  67.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.81k|      {}
_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.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.81k|         else {
   92|  3.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.81k|         }
   94|  3.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.81k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.80k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.01k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  1.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.01k|         }
   94|  1.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.01k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|      9|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.00k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.00k|         else {
   92|  1.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.00k|         }
   94|  1.00k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.00k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    851|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    150|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    150|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    150|         else {
   92|    150|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    150|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    150|         }
   94|    150|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    150|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     42|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    108|      {}
_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|  42.3k|      {
   65|  42.3k|         const typename ParseInput::action_t action_input( begin, in );
   66|  42.3k|         return Action< Rule >::apply( action_input, st... );
   67|  42.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  42.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    108|      {}
_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|  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_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  42.3k|      {}
_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|  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_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.54M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   116k|         else {
   92|   116k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   116k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   116k|         }
   94|   116k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.49M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  47.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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   836k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.63M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  58.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|  58.0k|         else {
   92|  58.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  58.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  58.0k|         }
   94|  58.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.19M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.41M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.77M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.68k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.62M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  41.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|  41.9k|         else {
   92|  41.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.9k|         }
   94|  41.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.77M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.73M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  40.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   796k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    134|      {}
_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.58k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   796k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   796k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     31|      {}
_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.56k|      {
   65|  3.56k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.56k|         return Action< Rule >::apply( action_input, st... );
   67|  3.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.56k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  42.3k|      {}
_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|  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_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  42.3k|      {}
_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|  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_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|  39.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|  39.6k|         else {
   92|  39.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.6k|         }
   94|  39.6k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  39.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.2k|         else {
   92|  45.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.2k|         }
   94|  45.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.2k|         else {
   92|  45.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.2k|         }
   94|  45.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.2k|      {}
_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|  45.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|  45.2k|         else {
   92|  45.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.2k|         }
   94|  45.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.2k|         else {
   92|  45.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.2k|         }
   94|  45.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.2k|      {}
_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.69k|      {
   65|  3.69k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.69k|         return Action< Rule >::apply( action_input, st... );
   67|  3.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.69k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  41.5k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   796k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   796k|         else {
   92|   796k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   796k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   796k|         }
   94|   796k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   796k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   796k|         else {
   92|   796k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   796k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   796k|         }
   94|   796k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_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.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_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.67k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.67k|      {}
_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.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_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  40.0k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.0k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.79k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.23k|      {
   88|       |         if constexpr( internal::has_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.23k|         else {
   92|  3.23k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.23k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.23k|         }
   94|  3.23k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.87k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.04k|         else {
   92|  3.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.04k|         }
   94|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  29.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  29.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.25k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  26.3k|      {}
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.21k|         else {
   92|  2.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.21k|         }
   94|  2.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.9k|      {}
_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.65k|      {
   65|  1.65k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.65k|         return Action< Rule >::apply( action_input, st... );
   67|  1.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.9k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  40.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_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_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  40.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  26.9k|      {}
_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.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|  4.73k|         else {
   92|  4.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.73k|         }
   94|  4.73k|      }
_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.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_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.40k|      {}
_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.33k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.33k|         else {
   92|  2.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.33k|         }
   94|  2.33k|      }
_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|   791k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   791k|         else {
   92|   791k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   791k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   791k|         }
   94|   791k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.33k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     65|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.33k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.33k|         else {
   92|  2.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.33k|         }
   94|  2.33k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  25.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  23.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.87k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.50k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   794k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   794k|         else {
   92|   794k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   794k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   794k|         }
   94|   794k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   794k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   794k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   794k|         else {
   92|   794k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   794k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   794k|         }
   94|   794k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.58M|      {
   88|       |         if constexpr( internal::has_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.58M|         else {
   92|  1.58M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.58M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.58M|         }
   94|  1.58M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.59M|      {
   88|       |         if constexpr( internal::has_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.59M|         else {
   92|  1.59M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.59M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.59M|         }
   94|  1.59M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.58M|      {
   88|       |         if constexpr( internal::has_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.58M|         else {
   92|  1.58M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.58M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.58M|         }
   94|  1.58M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   792k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   792k|         else {
   92|   792k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   792k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   792k|         }
   94|   792k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   792k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   792k|         else {
   92|   792k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   792k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   792k|         }
   94|   792k|      }
_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|   792k|      {
   65|   792k|         const typename ParseInput::action_t action_input( begin, in );
   66|   792k|         return Action< Rule >::apply( action_input, st... );
   67|   792k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   792k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.68k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.21k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    453|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.21k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  42.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.21k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  42.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.0k|         else {
   92|  42.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.0k|         }
   94|  42.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.0k|      {}
_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|  42.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|  42.0k|         else {
   92|  42.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.0k|         }
   94|  42.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.0k|         else {
   92|  42.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.0k|         }
   94|  42.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  42.0k|      {}
_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.51k|      {
   65|  4.51k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.51k|         return Action< Rule >::apply( action_input, st... );
   67|  4.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.5k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   594k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   594k|         else {
   92|   594k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   594k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   594k|         }
   94|   594k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   594k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   594k|         else {
   92|   594k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   594k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   594k|         }
   94|   594k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   604k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   604k|         else {
   92|   604k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   604k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   604k|         }
   94|   604k|      }
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  26.1k|      {}
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.1k|      {}
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_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_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.69k|         else {
   92|  3.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.69k|         }
   94|  3.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.88k|         else {
   92|  2.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88k|         }
   94|  2.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.69k|         else {
   92|  2.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.69k|         }
   94|  2.69k|      }
_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.34k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.34k|         else {
   92|  2.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.34k|         }
   94|  2.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.36k|      {
   65|  2.36k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.36k|         return Action< Rule >::apply( action_input, st... );
   67|  2.36k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  4.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.49k|         }
   94|  4.49k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  6.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.95k|         }
   94|  6.95k|      }
_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.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  17.8k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_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|      }
_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|   587k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   587k|         else {
   92|   587k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   587k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   587k|         }
   94|   587k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  17.3k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    289|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.44k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   589k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   589k|         else {
   92|   589k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   589k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   589k|         }
   94|   589k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   631k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   589k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   589k|         else {
   92|   589k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   589k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   589k|         }
   94|   589k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  68.5M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.25M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  67.2M|      {}
_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|   588k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   588k|         else {
   92|   588k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   588k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   588k|         }
   94|   588k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   588k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   588k|         else {
   92|   588k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   588k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   588k|         }
   94|   588k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   624k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  18.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|  18.0M|         else {
   92|  18.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.0M|         }
   94|  18.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  17.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|  17.4M|         else {
   92|  17.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.4M|         }
   94|  17.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  67.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  17.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|  17.4M|         else {
   92|  17.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.4M|         }
   94|  17.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  67.2M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  17.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|  17.4M|         else {
   92|  17.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.4M|         }
   94|  17.4M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   120M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.06M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   119M|      {}
_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|   245k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   245k|         else {
   92|   245k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   245k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   245k|         }
   94|   245k|      }
_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|   245k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   245k|         else {
   92|   245k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   245k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   245k|         }
   94|   245k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   898k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   245k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   245k|         else {
   92|   245k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   245k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   245k|         }
   94|   245k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.06M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   245k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   245k|         else {
   92|   245k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   245k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   245k|         }
   94|   245k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.06M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   354k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   706k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|   102k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   102k|         else {
   92|   102k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   102k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   102k|         }
   94|   102k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   102k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   102k|         else {
   92|   102k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   102k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   102k|         }
   94|   102k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   354k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   205k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   205k|         else {
   92|   205k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   205k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   205k|         }
   94|   205k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   354k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    267|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    267|      {
   49|    267|#if defined( __cpp_exceptions )
   50|    267|         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|    267|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   354k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   706k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   142k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   142k|         else {
   92|   142k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   142k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   142k|         }
   94|   142k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   706k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_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_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.04M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   371k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   671k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  39.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|  39.2k|         else {
   92|  39.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.2k|         }
   94|  39.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  39.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|  39.2k|         else {
   92|  39.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.2k|         }
   94|  39.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   283k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   283k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   283k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   423k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   103k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   103k|         else {
   92|   103k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   103k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   103k|         }
   94|   103k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   423k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   412k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.42k|         else {
   92|  5.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.42k|         }
   94|  5.42k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   897k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    365|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    365|      {
   49|    365|#if defined( __cpp_exceptions )
   50|    365|         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|    365|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   897k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  66.3M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  17.1M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  17.1M|         else {
   92|  17.1M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.1M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.1M|         }
   94|  17.1M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   119M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   119M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.60k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  67.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.31k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   622k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.31k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.31k|      {
   49|  1.31k|#if defined( __cpp_exceptions )
   50|  1.31k|         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
   51|       |#else
   52|       |         static_assert( internal::dependent_false< Rule >, "exception support required for normal< Rule >::raise()" );
   53|       |         (void)in;
   54|       |         std::terminate();
   55|       |#endif
   56|  1.31k|      }
_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|   588k|      {
   65|   588k|         const typename ParseInput::action_t action_input( begin, in );
   66|   588k|         return Action< Rule >::apply( action_input, st... );
   67|   588k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   622k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.88k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  21.6k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.25k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.77k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.77k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.8k|         else {
   92|  37.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.8k|         }
   94|  37.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.8k|      {}
_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|  37.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|  37.8k|         else {
   92|  37.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.8k|         }
   94|  37.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.8k|         else {
   92|  37.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.8k|         }
   94|  37.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.20k|      {
   65|  4.20k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.20k|         return Action< Rule >::apply( action_input, st... );
   67|  4.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.20k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.6k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.6k|         else {
   92|  12.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6k|         }
   94|  12.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.6k|         else {
   92|  12.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6k|         }
   94|  12.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  21.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|  21.6k|         else {
   92|  21.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.6k|         }
   94|  21.6k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.96k|      {
   88|       |         if constexpr( internal::has_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.96k|         else {
   92|  3.96k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.96k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.96k|         }
   94|  3.96k|      }
_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.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.41k|         else {
   92|  3.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.41k|         }
   94|  3.41k|      }
_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.83k|      {
   88|       |         if constexpr( internal::has_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.83k|         else {
   92|  2.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.83k|         }
   94|  2.83k|      }
_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.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|  2.57k|         else {
   92|  2.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.57k|         }
   94|  2.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.83k|      {
   65|  1.83k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.83k|         return Action< Rule >::apply( action_input, st... );
   67|  1.83k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.18k|         else {
   92|  4.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.18k|         }
   94|  4.18k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  2.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.95k|         }
   94|  2.95k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.62k|         else {
   92|  6.62k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.62k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.62k|         }
   94|  6.62k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.87k|         else {
   92|  2.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.87k|         }
   94|  2.87k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.82k|         else {
   92|  8.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.82k|         }
   94|  8.82k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.82k|         else {
   92|  8.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.82k|         }
   94|  8.82k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.72k|         else {
   92|  7.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.72k|         }
   94|  7.72k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.72k|         else {
   92|  7.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.72k|         }
   94|  7.72k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.0M|         else {
   92|  12.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.0M|         }
   94|  12.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.0M|         else {
   92|  12.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.0M|         }
   94|  12.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.0M|         else {
   92|  12.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.0M|         }
   94|  12.0M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.0M|         else {
   92|  12.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.0M|         }
   94|  12.0M|      }
_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|   176k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   176k|         else {
   92|   176k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   176k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   176k|         }
   94|   176k|      }
_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|   176k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   176k|         else {
   92|   176k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   176k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   176k|         }
   94|   176k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   176k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   176k|         else {
   92|   176k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   176k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   176k|         }
   94|   176k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   176k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   176k|         else {
   92|   176k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   176k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   176k|         }
   94|   176k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  52.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|  52.0k|         else {
   92|  52.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  52.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  52.0k|         }
   94|  52.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  52.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|  52.0k|         else {
   92|  52.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  52.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  52.0k|         }
   94|  52.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   104k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   104k|         else {
   92|   104k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   104k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   104k|         }
   94|   104k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   124k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   124k|         else {
   92|   124k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   124k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   124k|         }
   94|   124k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   198k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   198k|         else {
   92|   198k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   198k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   198k|         }
   94|   198k|      }
_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|  64.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|  64.7k|         else {
   92|  64.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  64.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  64.7k|         }
   94|  64.7k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  64.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|  64.7k|         else {
   92|  64.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  64.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  64.7k|         }
   94|  64.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.22k|         else {
   92|  1.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.22k|         }
   94|  1.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.9M|      {
   88|       |         if constexpr( internal::has_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.9M|         else {
   92|  11.9M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9M|         }
   94|  11.9M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  7.42k|      {
   65|  7.42k|         const typename ParseInput::action_t action_input( begin, in );
   66|  7.42k|         return Action< Rule >::apply( action_input, st... );
   67|  7.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.0k|      {}
_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|  34.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|  34.0k|         else {
   92|  34.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.0k|         }
   94|  34.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.0k|      {}
_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|  34.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|  34.0k|         else {
   92|  34.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.0k|         }
   94|  34.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.0k|      {}
_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|  34.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|  34.0k|         else {
   92|  34.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.0k|         }
   94|  34.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5applyITtTpTyENS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.14k|      {
   65|  3.14k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.14k|         return Action< Rule >::apply( action_input, st... );
   67|  3.14k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.14k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.89k|         else {
   92|  8.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.89k|         }
   94|  8.89k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.89k|         else {
   92|  8.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.89k|         }
   94|  8.89k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_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_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_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.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|  2.91k|         else {
   92|  2.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.91k|         }
   94|  2.91k|      }
_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.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.67k|         else {
   92|  2.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.67k|         }
   94|  2.67k|      }
_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.61k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.61k|         else {
   92|  2.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.61k|         }
   94|  2.61k|      }
_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.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.41k|         else {
   92|  2.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.41k|         }
   94|  2.41k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.16k|         else {
   92|  2.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.16k|         }
   94|  2.16k|      }
_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.03k|      {
   65|  1.03k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.03k|         return Action< Rule >::apply( action_input, st... );
   67|  1.03k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_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.98k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.98k|         else {
   92|  3.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.98k|         }
   94|  3.98k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_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.96k|      {
   88|       |         if constexpr( internal::has_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.96k|         else {
   92|  1.96k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.96k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.96k|         }
   94|  1.96k|      }
_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.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|  4.71k|         else {
   92|  4.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.71k|         }
   94|  4.71k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  1.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.95k|         }
   94|  1.95k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.65k|         else {
   92|  6.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.65k|         }
   94|  6.65k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.65k|         else {
   92|  6.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.65k|         }
   94|  6.65k|      }
_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.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|      }
_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.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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.96M|      {
   88|       |         if constexpr( internal::has_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.96M|         else {
   92|  9.96M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.96M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.96M|         }
   94|  9.96M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.96M|      {
   88|       |         if constexpr( internal::has_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.96M|         else {
   92|  9.96M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.96M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.96M|         }
   94|  9.96M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.96M|      {
   88|       |         if constexpr( internal::has_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.96M|         else {
   92|  9.96M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.96M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.96M|         }
   94|  9.96M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.96M|      {
   88|       |         if constexpr( internal::has_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.96M|         else {
   92|  9.96M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.96M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.96M|         }
   94|  9.96M|      }
_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|   131k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   131k|         else {
   92|   131k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   131k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   131k|         }
   94|   131k|      }
_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|   131k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   131k|         else {
   92|   131k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   131k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   131k|         }
   94|   131k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   131k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   131k|         else {
   92|   131k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   131k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   131k|         }
   94|   131k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   131k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   131k|         else {
   92|   131k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   131k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   131k|         }
   94|   131k|      }
_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|  45.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|  45.0k|         else {
   92|  45.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0k|         }
   94|  45.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.0k|         else {
   92|  45.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0k|         }
   94|  45.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  89.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|  89.9k|         else {
   92|  89.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  89.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  89.9k|         }
   94|  89.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  86.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|  86.4k|         else {
   92|  86.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.4k|         }
   94|  86.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   128k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   128k|         else {
   92|   128k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   128k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   128k|         }
   94|   128k|      }
_ZN3tao5pegtl6normalINS0_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|  27.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|  27.4k|         else {
   92|  27.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.4k|         }
   94|  27.4k|      }
_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|  27.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|  27.4k|         else {
   92|  27.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.4k|         }
   94|  27.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  59.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|  59.0k|         else {
   92|  59.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  59.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  59.0k|         }
   94|  59.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    831|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    831|         else {
   92|    831|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    831|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    831|         }
   94|    831|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.83M|      {
   88|       |         if constexpr( internal::has_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.83M|         else {
   92|  9.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.83M|         }
   94|  9.83M|      }
_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|  5.43k|      {
   65|  5.43k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.43k|         return Action< Rule >::apply( action_input, st... );
   67|  5.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.2k|         else {
   92|  31.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.2k|         }
   94|  31.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.2k|      {}
_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|  31.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|  31.2k|         else {
   92|  31.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.2k|         }
   94|  31.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.2k|         else {
   92|  31.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.2k|         }
   94|  31.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.2k|      {}
_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.20k|      {
   65|  3.20k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.20k|         return Action< Rule >::apply( action_input, st... );
   67|  3.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.19k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.0k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.27k|         else {
   92|  8.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.27k|         }
   94|  8.27k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.27k|         else {
   92|  8.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.27k|         }
   94|  8.27k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.3k|         else {
   92|  15.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.3k|         }
   94|  15.3k|      }
_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.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_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.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_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.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_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.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_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.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  2.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.95k|         }
   94|  2.95k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.74k|         else {
   92|  2.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.74k|         }
   94|  2.74k|      }
_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.55k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.55k|         else {
   92|  2.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.55k|         }
   94|  2.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.27k|         else {
   92|  2.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.27k|         }
   94|  2.27k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.06k|         else {
   92|  2.06k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.06k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.06k|         }
   94|  2.06k|      }
_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.35k|      {
   65|  1.35k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.35k|         return Action< Rule >::apply( action_input, st... );
   67|  1.35k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.18k|         else {
   92|  3.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.18k|         }
   94|  3.18k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.66k|      {
   88|       |         if constexpr( internal::has_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.66k|         else {
   92|  3.66k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.66k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.66k|         }
   94|  3.66k|      }
_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.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.85k|         else {
   92|  1.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.85k|         }
   94|  1.85k|      }
_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.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.81k|         else {
   92|  1.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.81k|         }
   94|  1.81k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.71k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.71k|         else {
   92|  3.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.71k|         }
   94|  3.71k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.80k|         else {
   92|  1.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.80k|         }
   94|  1.80k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.51k|         else {
   92|  5.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.51k|         }
   94|  5.51k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.51k|         else {
   92|  5.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.51k|         }
   94|  5.51k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  4.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.95k|         }
   94|  4.95k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  4.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  4.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.95k|         }
   94|  4.95k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.67M|      {
   88|       |         if constexpr( internal::has_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.67M|         else {
   92|  2.67M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.67M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.67M|         }
   94|  2.67M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.66M|      {
   88|       |         if constexpr( internal::has_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.66M|         else {
   92|  2.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.66M|         }
   94|  2.66M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.66M|      {
   88|       |         if constexpr( internal::has_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.66M|         else {
   92|  2.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.66M|         }
   94|  2.66M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.66M|      {
   88|       |         if constexpr( internal::has_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.66M|         else {
   92|  2.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.66M|         }
   94|  2.66M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.36k|         else {
   92|  8.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.36k|         }
   94|  8.36k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.36k|         else {
   92|  8.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.36k|         }
   94|  8.36k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.36k|         else {
   92|  8.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.36k|         }
   94|  8.36k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.36k|         else {
   92|  8.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.36k|         }
   94|  8.36k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.02k|         else {
   92|  6.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.02k|         }
   94|  6.02k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.34k|         else {
   92|  5.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.34k|         }
   94|  5.34k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.30k|         else {
   92|  7.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.30k|         }
   94|  7.30k|      }
_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|  1.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|  1.51k|         else {
   92|  1.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.51k|         }
   94|  1.51k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.51k|         else {
   92|  1.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.51k|         }
   94|  1.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.82k|         else {
   92|  3.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.82k|         }
   94|  3.82k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    270|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    270|         else {
   92|    270|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    270|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    270|         }
   94|    270|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.66M|      {
   88|       |         if constexpr( internal::has_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.66M|         else {
   92|  2.66M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.66M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.66M|         }
   94|  2.66M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.74k|      {
   65|  4.74k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.74k|         return Action< Rule >::apply( action_input, st... );
   67|  4.74k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.72k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.72k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.2k|      {}
_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|  28.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|  28.2k|         else {
   92|  28.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.2k|         }
   94|  28.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.2k|      {}
_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|  28.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|  28.2k|         else {
   92|  28.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.2k|         }
   94|  28.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.2k|      {}
_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|  28.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|  28.2k|         else {
   92|  28.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.2k|         }
   94|  28.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.2k|      {}
_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.96k|      {
   65|  3.96k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.96k|         return Action< Rule >::apply( action_input, st... );
   67|  3.96k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  10.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.7k|         else {
   92|  10.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.7k|         }
   94|  10.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.7k|         else {
   92|  10.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.7k|         }
   94|  10.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  20.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  20.7k|         else {
   92|  20.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.7k|         }
   94|  20.7k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_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.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_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.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_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.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_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.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_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.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|      }
_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|  3.28k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.28k|         else {
   92|  3.28k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.28k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.28k|         }
   94|  3.28k|      }
_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.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|      }
_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.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.67k|         else {
   92|  2.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.67k|         }
   94|  2.67k|      }
_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.54k|      {
   65|  1.54k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.54k|         return Action< Rule >::apply( action_input, st... );
   67|  1.54k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.34k|         else {
   92|  5.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.34k|         }
   94|  5.34k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.64k|         else {
   92|  2.64k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.64k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.64k|         }
   94|  2.64k|      }
_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|  5.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|  5.24k|         else {
   92|  5.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.24k|         }
   94|  5.24k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.73k|         else {
   92|  7.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.73k|         }
   94|  7.73k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.73k|         else {
   92|  7.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.73k|         }
   94|  7.73k|      }
_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|  6.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.35k|         else {
   92|  6.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.35k|         }
   94|  6.35k|      }
_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|  6.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.35k|         else {
   92|  6.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.35k|         }
   94|  6.35k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.02M|      {
   88|       |         if constexpr( internal::has_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.02M|         else {
   92|  9.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.02M|         }
   94|  9.02M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.02M|      {
   88|       |         if constexpr( internal::has_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.02M|         else {
   92|  9.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.02M|         }
   94|  9.02M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.02M|      {
   88|       |         if constexpr( internal::has_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.02M|         else {
   92|  9.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.02M|         }
   94|  9.02M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.02M|      {
   88|       |         if constexpr( internal::has_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.02M|         else {
   92|  9.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.02M|         }
   94|  9.02M|      }
_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|  97.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|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  97.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|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  97.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|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  97.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|  97.4k|         else {
   92|  97.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.4k|         }
   94|  97.4k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  28.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|  28.2k|         else {
   92|  28.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.2k|         }
   94|  28.2k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  28.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|  28.2k|         else {
   92|  28.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.2k|         }
   94|  28.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  56.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|  56.3k|         else {
   92|  56.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  56.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  56.3k|         }
   94|  56.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  69.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|  69.2k|         else {
   92|  69.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  69.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  69.2k|         }
   94|  69.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   104k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   104k|         else {
   92|   104k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   104k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   104k|         }
   94|   104k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  29.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|  29.7k|         else {
   92|  29.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.7k|         }
   94|  29.7k|      }
_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|  29.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|  29.7k|         else {
   92|  29.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.7k|         }
   94|  29.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  39.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  39.4k|         else {
   92|  39.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.4k|         }
   94|  39.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    642|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    642|         else {
   92|    642|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    642|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    642|         }
   94|    642|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.92M|      {
   88|       |         if constexpr( internal::has_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.92M|         else {
   92|  8.92M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.92M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.92M|         }
   94|  8.92M|      }
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.26k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.26k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_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|  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_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5applyITtTpTyENS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.52k|      {
   65|  3.52k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.52k|         return Action< Rule >::apply( action_input, st... );
   67|  3.52k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.52k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.1k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_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_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.64M|      {
   88|       |         if constexpr( internal::has_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.64M|         else {
   92|  1.64M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.64M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.64M|         }
   94|  1.64M|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.51k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.24k|         else {
   92|  3.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.24k|         }
   94|  3.24k|      }
_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|  3.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.41k|         else {
   92|  2.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.41k|         }
   94|  2.41k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.92k|      {
   88|       |         if constexpr( internal::has_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.92k|         else {
   92|  1.92k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.92k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.92k|         }
   94|  1.92k|      }
_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|  2.03k|      {
   65|  2.03k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.03k|         return Action< Rule >::apply( action_input, st... );
   67|  2.03k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.51k|         else {
   92|  3.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.51k|         }
   94|  3.51k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.89k|         else {
   92|  4.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.89k|         }
   94|  4.89k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.47k|         else {
   92|  2.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.47k|         }
   94|  2.47k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.47k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.42k|         else {
   92|  2.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.42k|         }
   94|  2.42k|      }
_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|   162k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   162k|         else {
   92|   162k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   162k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   162k|         }
   94|   162k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.42k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     54|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.42k|         else {
   92|  2.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.42k|         }
   94|  2.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.24k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.26k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   164k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   164k|         else {
   92|   164k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   164k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   164k|         }
   94|   164k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   164k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   164k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   164k|         else {
   92|   164k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   164k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   164k|         }
   94|   164k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   491k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   828k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   828k|         else {
   92|   828k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   828k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   828k|         }
   94|   828k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   337k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   153k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   326k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   326k|         else {
   92|   326k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   326k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   326k|         }
   94|   326k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   326k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   326k|         else {
   92|   326k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   326k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   326k|         }
   94|   326k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   326k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   326k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   326k|         else {
   92|   326k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   326k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   326k|         }
   94|   326k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   152k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   152k|         else {
   92|   152k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   152k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   152k|         }
   94|   152k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   326k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     43|      {}
_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|   163k|      {
   65|   163k|         const typename ParseInput::action_t action_input( begin, in );
   66|   163k|         return Action< Rule >::apply( action_input, st... );
   67|   163k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   163k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.25k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    426|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.5k|      {}
_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|  21.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|  21.5k|         else {
   92|  21.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.5k|         }
   94|  21.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.5k|      {}
_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|  21.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|  21.5k|         else {
   92|  21.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.5k|         }
   94|  21.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.5k|      {}
_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|  21.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|  21.5k|         else {
   92|  21.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.5k|         }
   94|  21.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  21.5k|      {}
_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|  3.17k|      {
   65|  3.17k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.17k|         return Action< Rule >::apply( action_input, st... );
   67|  3.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.17k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.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|  9.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  9.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.01k|         }
   94|  9.01k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  9.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.01k|         }
   94|  9.01k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|  19.0k|         else {
   92|  19.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.0k|         }
   94|  19.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.95k|      {
   88|       |         if constexpr( internal::has_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.95k|         else {
   92|  2.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.95k|         }
   94|  2.95k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.86k|         else {
   92|  2.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.86k|         }
   94|  2.86k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.53k|         else {
   92|  2.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.53k|         }
   94|  2.53k|      }
_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|  2.34k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.34k|         else {
   92|  2.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.34k|         }
   94|  2.34k|      }
_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|  2.08k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.08k|         else {
   92|  2.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.08k|         }
   94|  2.08k|      }
_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.27k|      {
   65|  1.27k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.27k|         return Action< Rule >::apply( action_input, st... );
   67|  1.27k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.16k|         else {
   92|  3.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.16k|         }
   94|  3.16k|      }
_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|  5.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|  5.13k|         else {
   92|  5.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.13k|         }
   94|  5.13k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.60k|         else {
   92|  2.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.60k|         }
   94|  2.60k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.53k|         else {
   92|  2.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.53k|         }
   94|  2.53k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.56k|         else {
   92|  4.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.56k|         }
   94|  4.56k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.52k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.52k|         else {
   92|  2.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.52k|         }
   94|  2.52k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.96k|      {
   88|       |         if constexpr( internal::has_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.96k|         else {
   92|  5.96k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.96k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.96k|         }
   94|  5.96k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.96k|      {
   88|       |         if constexpr( internal::has_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.96k|         else {
   92|  5.96k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.96k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.96k|         }
   94|  5.96k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.03k|         else {
   92|  5.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.03k|         }
   94|  5.03k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.03k|         else {
   92|  5.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.03k|         }
   94|  5.03k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.46M|      {
   88|       |         if constexpr( internal::has_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.46M|         else {
   92|  7.46M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.46M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.46M|         }
   94|  7.46M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.46M|      {
   88|       |         if constexpr( internal::has_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.46M|         else {
   92|  7.46M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.46M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.46M|         }
   94|  7.46M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.46M|      {
   88|       |         if constexpr( internal::has_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.46M|         else {
   92|  7.46M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.46M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.46M|         }
   94|  7.46M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.46M|      {
   88|       |         if constexpr( internal::has_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.46M|         else {
   92|  7.46M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.46M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.46M|         }
   94|  7.46M|      }
_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|  75.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|  75.4k|         else {
   92|  75.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.4k|         }
   94|  75.4k|      }
_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|  75.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|  75.4k|         else {
   92|  75.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.4k|         }
   94|  75.4k|      }
_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|  75.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|  75.4k|         else {
   92|  75.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.4k|         }
   94|  75.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  75.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|  75.4k|         else {
   92|  75.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.4k|         }
   94|  75.4k|      }
_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|  19.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|  19.0k|         else {
   92|  19.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.0k|         }
   94|  19.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|  19.0k|         else {
   92|  19.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.0k|         }
   94|  19.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.1k|         else {
   92|  38.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.1k|         }
   94|  38.1k|      }
_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|  56.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|  56.4k|         else {
   92|  56.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  56.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  56.4k|         }
   94|  56.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|  85.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|  85.2k|         else {
   92|  85.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.2k|         }
   94|  85.2k|      }
_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|  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|      }
_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|  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|      }
_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|  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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    598|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    598|         else {
   92|    598|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    598|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    598|         }
   94|    598|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.38M|         else {
   92|  7.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.38M|         }
   94|  7.38M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.78k|      {
   65|  4.78k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.78k|         return Action< Rule >::apply( action_input, st... );
   67|  4.78k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.57k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.57k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.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|  18.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|  18.6k|         else {
   92|  18.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.6k|         }
   94|  18.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.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|  18.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|  18.6k|         else {
   92|  18.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.6k|         }
   94|  18.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  18.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|  18.6k|         else {
   92|  18.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.6k|         }
   94|  18.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  18.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|  6.79k|      {
   65|  6.79k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.79k|         return Action< Rule >::apply( action_input, st... );
   67|  6.79k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.78k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   812k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   812k|         else {
   92|   812k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   812k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   812k|         }
   94|   812k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   812k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   812k|         else {
   92|   812k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   812k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   812k|         }
   94|   812k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   859k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   859k|         else {
   92|   859k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   859k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   859k|         }
   94|   859k|      }
_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|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  6.76k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  6.76k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.56k|         else {
   92|  6.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.56k|         }
   94|  6.56k|      }
_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.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|  6.07k|         else {
   92|  6.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.07k|         }
   94|  6.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.88k|         else {
   92|  5.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.88k|         }
   94|  5.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.53k|         else {
   92|  5.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.53k|         }
   94|  5.53k|      }
_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.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.27k|         else {
   92|  5.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.27k|         }
   94|  5.27k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.76k|         else {
   92|  6.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76k|         }
   94|  6.76k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.20k|         else {
   92|  7.20k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.20k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.20k|         }
   94|  7.20k|      }
_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.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_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  4.22k|      {}
_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.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|  4.09k|         else {
   92|  4.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.09k|         }
   94|  4.09k|      }
_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|   803k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   803k|         else {
   92|   803k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   803k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   803k|         }
   94|   803k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.97k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     36|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.20k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   808k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   808k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   808k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    318|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   808k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   808k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   808k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   808k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   808k|         else {
   92|   808k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   808k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   808k|         }
   94|   808k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   808k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   807k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.19k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   807k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   807k|         else {
   92|   807k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   807k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   807k|         }
   94|   807k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   807k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  26.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|  26.6M|         else {
   92|  26.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.6M|         }
   94|  26.6M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  26.6M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  25.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   807k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.19k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   807k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   807k|         else {
   92|   807k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   807k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   807k|         }
   94|   807k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   807k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   807k|         else {
   92|   807k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   807k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   807k|         }
   94|   807k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   807k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   807k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   807k|         else {
   92|   807k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   807k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   807k|         }
   94|   807k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   807k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  41.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   766k|      {}
_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|  41.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|  41.0k|         else {
   92|  41.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.0k|         }
   94|  41.0k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  41.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|  41.0k|         else {
   92|  41.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.0k|         }
   94|  41.0k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  41.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  53.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|  53.3M|         else {
   92|  53.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.3M|         }
   94|  53.3M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  53.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  41.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  53.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  53.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|  53.2M|         else {
   92|  53.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.2M|         }
   94|  53.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  53.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  53.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|  53.2M|         else {
   92|  53.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.2M|         }
   94|  53.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  53.2M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  53.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|  53.2M|         else {
   92|  53.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.2M|         }
   94|  53.2M|      }
_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|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_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|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   163k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  51.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|  51.5k|         else {
   92|  51.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  51.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  51.5k|         }
   94|  51.5k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  51.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|  51.5k|         else {
   92|  51.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  51.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  51.5k|         }
   94|  51.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   102k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   102k|         else {
   92|   102k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   102k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   102k|         }
   94|   102k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   111k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   111k|         else {
   92|   111k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   111k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   111k|         }
   94|   111k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   142k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   142k|         else {
   92|   142k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   142k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   142k|         }
   94|   142k|      }
_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|  26.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|  26.3k|         else {
   92|  26.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.3k|         }
   94|  26.3k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  26.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|  26.3k|         else {
   92|  26.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.3k|         }
   94|  26.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  85.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|  85.2k|         else {
   92|  85.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.2k|         }
   94|  85.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    422|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    422|         else {
   92|    422|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    422|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    422|         }
   94|    422|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   162k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     66|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     66|      {
   49|     66|#if defined( __cpp_exceptions )
   50|     66|         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|     66|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   162k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  53.1M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  53.1M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  53.1M|         else {
   92|  53.1M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.1M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.1M|         }
   94|  53.1M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  53.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    289|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  40.6k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    289|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    289|      {
   49|    289|#if defined( __cpp_exceptions )
   50|    289|         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|    289|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  40.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   766k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   806k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   806k|      {
   65|   806k|         const typename ParseInput::action_t action_input( begin, in );
   66|   806k|         return Action< Rule >::apply( action_input, st... );
   67|   806k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   805k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.19k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.71k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    739|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.71k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  12.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.71k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  12.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.6k|         else {
   92|  12.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6k|         }
   94|  12.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  12.6k|      {}
_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|  12.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|  12.6k|         else {
   92|  12.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6k|         }
   94|  12.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  12.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  12.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|  12.6k|         else {
   92|  12.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  12.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  12.6k|         }
   94|  12.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  12.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.05k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  8.60k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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_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.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|      }
_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.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|      }
_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.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|      }
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_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|      }
_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.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|      }
_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.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.81k|         else {
   92|  3.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.81k|         }
   94|  3.81k|      }
_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.70k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.70k|         else {
   92|  3.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.70k|         }
   94|  3.70k|      }
_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.49k|      {
   88|       |         if constexpr( internal::has_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.49k|         else {
   92|  3.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.49k|         }
   94|  3.49k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.30k|         else {
   92|  3.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.30k|         }
   94|  3.30k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.01k|      {
   88|       |         if constexpr( internal::has_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.01k|         else {
   92|  3.01k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.01k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.01k|         }
   94|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_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.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_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.36k|         else {
   92|  4.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.36k|         }
   94|  4.36k|      }
_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.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|  2.22k|         else {
   92|  2.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.22k|         }
   94|  2.22k|      }
_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.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|      }
_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.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.85k|         else {
   92|  4.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.85k|         }
   94|  4.85k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.14k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.14k|         else {
   92|  2.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.14k|         }
   94|  2.14k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.44k|         else {
   92|  7.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.44k|         }
   94|  7.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.44k|         else {
   92|  7.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.44k|         }
   94|  7.44k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.53k|         else {
   92|  6.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.53k|         }
   94|  6.53k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.53k|         else {
   92|  6.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.53k|         }
   94|  6.53k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.60M|         else {
   92|  8.60M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.60M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.60M|         }
   94|  8.60M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.59M|      {
   88|       |         if constexpr( internal::has_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.59M|         else {
   92|  8.59M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.59M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.59M|         }
   94|  8.59M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.59M|      {
   88|       |         if constexpr( internal::has_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.59M|         else {
   92|  8.59M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.59M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.59M|         }
   94|  8.59M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.59M|      {
   88|       |         if constexpr( internal::has_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.59M|         else {
   92|  8.59M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.59M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.59M|         }
   94|  8.59M|      }
_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|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_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|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   163k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   163k|         else {
   92|   163k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   163k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   163k|         }
   94|   163k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  53.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  53.1k|         else {
   92|  53.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.1k|         }
   94|  53.1k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  53.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  53.1k|         else {
   92|  53.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.1k|         }
   94|  53.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   106k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   106k|         else {
   92|   106k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   106k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   106k|         }
   94|   106k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   188k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   188k|         else {
   92|   188k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   188k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   188k|         }
   94|   188k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  70.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|  70.1k|         else {
   92|  70.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.1k|         }
   94|  70.1k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  70.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|  70.1k|         else {
   92|  70.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.1k|         }
   94|  70.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.3k|         else {
   92|  40.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.3k|         }
   94|  40.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.03k|         else {
   92|  1.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.03k|         }
   94|  1.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.43M|      {
   88|       |         if constexpr( internal::has_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.43M|         else {
   92|  8.43M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.43M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.43M|         }
   94|  8.43M|      }
_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|  6.24k|      {
   65|  6.24k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.24k|         return Action< Rule >::apply( action_input, st... );
   67|  6.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  8.98k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  8.98k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  31.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  8.98k|      {}
_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|  28.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|  28.6k|         else {
   92|  28.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.6k|         }
   94|  28.6k|      }
_ZN3tao5pegtl6normalINS0_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|  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_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  28.3k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  6.75k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_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|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    108|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    108|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  37.9k|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.9k|         else {
   92|  37.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.9k|         }
   94|  37.9k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  37.9k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.9k|         else {
   92|  37.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.9k|         }
   94|  37.9k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|  4.58k|      {
   49|  4.58k|#if defined( __cpp_exceptions )
   50|  4.58k|         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.58k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  33.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  33.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|  42.5k|   {
   43|  42.5k|      return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   44|  42.5k|   }

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

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

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