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

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

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

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

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

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

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

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

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

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

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

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

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

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

_ZN8usbguard4RuleC2Ev:
   42|   106k|    : d_pointer(usbguard::make_unique<RulePrivate>())
   43|   106k|  {
   44|   106k|  }
_ZN8usbguard4RuleD2Ev:
   46|   106k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   54|  67.1k|  {
   55|  67.1k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   56|  67.1k|    return *this;
   57|  67.1k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   70|  38.0k|  {
   71|  38.0k|    d_pointer->setTarget(target);
   72|  38.0k|  }
_ZNK8usbguard4Rule9getTargetEv:
   75|  10.3k|  {
   76|  10.3k|    return d_pointer->getTarget();
   77|  10.3k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   80|  2.49k|  {
   81|  2.49k|    d_pointer->setDeviceID(value);
   82|  2.49k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   95|   857k|  {
   96|   857k|    return d_pointer->attributeDeviceID();
   97|   857k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  115|  9.17k|  {
  116|  9.17k|    return d_pointer->attributeSerial();
  117|  9.17k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  135|  7.71k|  {
  136|  7.71k|    return d_pointer->attributeLabel();
  137|  7.71k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  155|  8.49k|  {
  156|  8.49k|    return d_pointer->attributeWithConnectType();
  157|  8.49k|  }
_ZN8usbguard4Rule13attributeNameEv:
  175|   321k|  {
  176|   321k|    return d_pointer->attributeName();
  177|   321k|  }
_ZN8usbguard4Rule13attributeHashEv:
  195|  12.8k|  {
  196|  12.8k|    return d_pointer->attributeHash();
  197|  12.8k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  215|  10.7k|  {
  216|  10.7k|    return d_pointer->attributeParentHash();
  217|  10.7k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  235|  9.56k|  {
  236|  9.56k|    return d_pointer->attributeViaPort();
  237|  9.56k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  245|   169k|  {
  246|   169k|    return d_pointer->attributeWithInterface();
  247|   169k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  255|   648k|  {
  256|   648k|    return d_pointer->attributeConditions();
  257|   648k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  333|  38.0k|  {
  334|  43.7k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (334:28): [True: 43.7k, False: 0]
  ------------------
  335|  43.7k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (335:11): [True: 38.0k, False: 5.75k]
  ------------------
  336|  38.0k|        return ttable_entry.second;
  337|  38.0k|      }
  338|  43.7k|    }
  339|       |
  340|      0|    throw std::runtime_error("Invalid rule target string");
  341|  38.0k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  387|  15.2k|  {
  388|  58.4k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (388:28): [True: 58.4k, False: 0]
  ------------------
  389|  58.4k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (389:11): [True: 15.2k, False: 43.1k]
  ------------------
  390|  15.2k|        return ttable_entry.second;
  391|  15.2k|      }
  392|  58.4k|    }
  393|       |
  394|      0|    throw std::runtime_error("Invalid set operator string");
  395|  15.2k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  300|  3.45k|      {
  301|  3.45k|        return count() == 0;
  302|  3.45k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  289|  8.44k|      {
  290|  8.44k|        return _values.size();
  291|  8.44k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.65k|      {
  250|  1.65k|        _set_operator = op;
  251|  1.65k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  279|   855k|      {
  280|   855k|        _values.push_back(value);
  281|   855k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  300|  20.0k|      {
  301|  20.0k|        return count() == 0;
  302|  20.0k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  289|  20.0k|      {
  290|  20.0k|        return _values.size();
  291|  20.0k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  249|  10.2k|      {
  250|  10.2k|        _set_operator = op;
  251|  10.2k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  279|   348k|      {
  280|   348k|        _values.push_back(value);
  281|   348k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  300|  3.46k|      {
  301|  3.46k|        return count() == 0;
  302|  3.46k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  289|  3.46k|      {
  290|  3.46k|        return _values.size();
  291|  3.46k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  249|  2.05k|      {
  250|  2.05k|        _set_operator = op;
  251|  2.05k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  279|   163k|      {
  280|   163k|        _values.push_back(value);
  281|   163k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  300|  6.00k|      {
  301|  6.00k|        return count() == 0;
  302|  6.00k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  289|  6.00k|      {
  290|  6.00k|        return _values.size();
  291|  6.00k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.32k|      {
  250|  1.32k|        _set_operator = op;
  251|  1.32k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  269|   639k|      {
  270|   639k|        _values.emplace_back(std::move(value));
  271|   639k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  241|  67.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  241|   470k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  241|  67.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  241|  67.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  224|   173k|      {
  225|   173k|        _name = name;
  226|   173k|        _set_operator = SetOperator::Equals;
  227|   173k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  224|  1.21M|      {
  225|  1.21M|        _name = name;
  226|  1.21M|        _set_operator = SetOperator::Equals;
  227|  1.21M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  224|   173k|      {
  225|   173k|        _name = name;
  226|   173k|        _set_operator = SetOperator::Equals;
  227|   173k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  224|   173k|      {
  225|   173k|        _name = name;
  226|   173k|        _set_operator = SetOperator::Equals;
  227|   173k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  384|  2.49k|      {
  385|  2.49k|        if (count() > 1) {
  ------------------
  |  Branch (385:13): [True: 0, False: 2.49k]
  ------------------
  386|      0|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  387|      0|        }
  388|       |
  389|  2.49k|        if (count() == 0) {
  ------------------
  |  Branch (389:13): [True: 2.49k, False: 0]
  ------------------
  390|  2.49k|          append(value);
  391|  2.49k|        }
  392|      0|        else {
  393|      0|          _values[0] = value;
  394|      0|        }
  395|  2.49k|      }

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

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

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

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

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

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

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    279|{
   36|    279|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    279|   constexpr auto begin = sv.find( '=' );
   38|    279|   static_assert( begin != std::string_view::npos );
   39|    279|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    279|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    359|{
   36|    359|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    359|   constexpr auto begin = sv.find( '=' );
   38|    359|   static_assert( begin != std::string_view::npos );
   39|    359|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    359|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.30k|{
   36|  1.30k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.30k|   constexpr auto begin = sv.find( '=' );
   38|  1.30k|   static_assert( begin != std::string_view::npos );
   39|  1.30k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.30k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     61|{
   36|     61|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     61|   constexpr auto begin = sv.find( '=' );
   38|     61|   static_assert( begin != std::string_view::npos );
   39|     61|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     61|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    270|{
   36|    270|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    270|   constexpr auto begin = sv.find( '=' );
   38|    270|   static_assert( begin != std::string_view::npos );
   39|    270|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    270|}
_ZN3tao5pegtl8demangleINS0_3eofEEENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEv:
   35|  4.53k|{
   36|  4.53k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.53k|   constexpr auto begin = sv.find( '=' );
   38|  4.53k|   static_assert( begin != std::string_view::npos );
   39|  4.53k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.53k|}

_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|  40.6k|      {
   45|  40.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  40.6k|      }
_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|  37.7k|      {
   45|  37.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  37.7k|      }
_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|  34.3k|      {
   45|  34.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  34.3k|      }
_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|  30.5k|      {
   45|  30.5k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  30.5k|      }
_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|  27.6k|      {
   45|  27.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  27.6k|      }
_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|  24.9k|      {
   45|  24.9k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  24.9k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser22with_interface_actionsEJNS4_14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  22.0k|      {
   45|  22.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  22.0k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser25with_connect_type_actionsEJNS4_14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  19.0k|      {
   45|  19.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  19.0k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser17condition_actionsEJNS4_14rule_attributeINS4_6str_ifENS4_9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  16.5k|      {
   45|  16.5k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  16.5k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser13label_actionsEJNS4_14rule_attributeINS4_9str_labelENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  11.3k|      {
   45|  11.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  11.3k|      }

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

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

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

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.66M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.66M|      else {
   20|  3.66M|         in.bump_in_this_line( count );
   21|  3.66M|      }
   22|  3.66M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  10.3k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  10.3k|      else {
   20|  10.3k|         in.bump_in_this_line( count );
   21|  10.3k|      }
   22|  10.3k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  34.3k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  34.3k|      else {
   20|  34.3k|         in.bump_in_this_line( count );
   21|  34.3k|      }
   22|  34.3k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.70k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.70k|      else {
   20|  2.70k|         in.bump_in_this_line( count );
   21|  2.70k|      }
   22|  2.70k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     14|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     14|      else {
   20|     14|         in.bump_in_this_line( count );
   21|     14|      }
   22|     14|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    946|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    946|      else {
   20|    946|         in.bump_in_this_line( count );
   21|    946|      }
   22|    946|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     44|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     44|      else {
   20|     44|         in.bump_in_this_line( count );
   21|     44|      }
   22|     44|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.37M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.37M|      else {
   20|  1.37M|         in.bump_in_this_line( count );
   21|  1.37M|      }
   22|  1.37M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.86M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.86M|      else {
   20|  1.86M|         in.bump_in_this_line( count );
   21|  1.86M|      }
   22|  1.86M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.18M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.18M|      else {
   20|  1.18M|         in.bump_in_this_line( count );
   21|  1.18M|      }
   22|  1.18M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.45k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.45k|      else {
   20|  3.45k|         in.bump_in_this_line( count );
   21|  3.45k|      }
   22|  3.45k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.95k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.95k|      else {
   20|  1.95k|         in.bump_in_this_line( count );
   21|  1.95k|      }
   22|  1.95k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.51k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.51k|      else {
   20|  2.51k|         in.bump_in_this_line( count );
   21|  2.51k|      }
   22|  2.51k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.50k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.50k|      else {
   20|  2.50k|         in.bump_in_this_line( count );
   21|  2.50k|      }
   22|  2.50k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.42k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.42k|      else {
   20|  2.42k|         in.bump_in_this_line( count );
   21|  2.42k|      }
   22|  2.42k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.16k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.16k|      else {
   20|  3.16k|         in.bump_in_this_line( count );
   21|  3.16k|      }
   22|  3.16k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.73k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.73k|      else {
   20|  2.73k|         in.bump_in_this_line( count );
   21|  2.73k|      }
   22|  2.73k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  24.7k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  24.7k|      else {
   20|  24.7k|         in.bump_in_this_line( count );
   21|  24.7k|      }
   22|  24.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  21.1k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  21.1k|      else {
   20|  21.1k|         in.bump_in_this_line( count );
   21|  21.1k|      }
   22|  21.1k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.67k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.67k|      else {
   20|  3.67k|         in.bump_in_this_line( count );
   21|  3.67k|      }
   22|  3.67k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   711k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   711k|      else {
   20|   711k|         in.bump_in_this_line( count );
   21|   711k|      }
   22|   711k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   967k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   967k|      else {
   20|   967k|         in.bump_in_this_line( count );
   21|   967k|      }
   22|   967k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   345k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   345k|      else {
   20|   345k|         in.bump_in_this_line( count );
   21|   345k|      }
   22|   345k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   275k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   275k|      else {
   20|   275k|         in.bump_in_this_line( count );
   21|   275k|      }
   22|   275k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   397k|   {
   16|   397k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|   397k|         in.bump( count );
   18|       |      }
   19|       |      else {
   20|       |         in.bump_in_this_line( count );
   21|       |      }
   22|   397k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   102M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   102M|      else {
   20|   102M|         in.bump_in_this_line( count );
   21|   102M|      }
   22|   102M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.17k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.17k|      else {
   20|  4.17k|         in.bump_in_this_line( count );
   21|  4.17k|      }
   22|  4.17k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.23k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.23k|      else {
   20|  3.23k|         in.bump_in_this_line( count );
   21|  3.23k|      }
   22|  3.23k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.01k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.01k|      else {
   20|  3.01k|         in.bump_in_this_line( count );
   21|  3.01k|      }
   22|  3.01k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.23k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.23k|      else {
   20|  3.23k|         in.bump_in_this_line( count );
   21|  3.23k|      }
   22|  3.23k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.46k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.46k|      else {
   20|  3.46k|         in.bump_in_this_line( count );
   21|  3.46k|      }
   22|  3.46k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.76k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.76k|      else {
   20|  2.76k|         in.bump_in_this_line( count );
   21|  2.76k|      }
   22|  2.76k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  6.00k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  6.00k|      else {
   20|  6.00k|         in.bump_in_this_line( count );
   21|  6.00k|      }
   22|  6.00k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|    498|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    498|      else {
   20|    498|         in.bump_in_this_line( count );
   21|    498|      }
   22|    498|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   641k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   641k|      else {
   20|   641k|         in.bump_in_this_line( count );
   21|   641k|      }
   22|   641k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  28.8M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  28.8M|      else {
   20|  28.8M|         in.bump_in_this_line( count );
   21|  28.8M|      }
   22|  28.8M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  36.1k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  36.1k|      else {
   20|  36.1k|         in.bump_in_this_line( count );
   21|  36.1k|      }
   22|  36.1k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  36.1k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  36.1k|      else {
   20|  36.1k|         in.bump_in_this_line( count );
   21|  36.1k|      }
   22|  36.1k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc108ELc97ELc98ELc101ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.36k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.36k|      else {
   20|  4.36k|         in.bump_in_this_line( count );
   21|  4.36k|      }
   22|  4.36k|   }

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

_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|  71.6k|      {
   38|  71.6k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 10.3k, False: 61.2k]
  ------------------
   39|  10.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  10.3k|            return true;
   41|  10.3k|         }
   42|  61.2k|         return Default;
   43|  71.6k|      }
_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|   317k|      {
   38|   317k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 316k, False: 996]
  ------------------
   39|   316k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   316k|            return true;
   41|   316k|         }
   42|    996|         return Default;
   43|   317k|      }
_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|  15.6M|      {
   38|  15.6M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 239k, False: 15.3M]
  ------------------
   39|   239k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   239k|            return true;
   41|   239k|         }
   42|  15.3M|         return Default;
   43|  15.6M|      }
_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|   239k|      {
   38|   239k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 106k, False: 133k]
  ------------------
   39|   106k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   106k|            return true;
   41|   106k|         }
   42|   133k|         return Default;
   43|   239k|      }
_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|   133k|      {
   38|   133k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 34.9k, False: 98.5k]
  ------------------
   39|  34.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  34.9k|            return true;
   41|  34.9k|         }
   42|  98.5k|         return Default;
   43|   133k|      }
_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.78k|      {
   38|  8.78k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 7.54k, False: 1.23k]
  ------------------
   39|  7.54k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  7.54k|            return true;
   41|  7.54k|         }
   42|  1.23k|         return Default;
   43|  8.78k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  9.27M|      {
   38|  9.27M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 127k, False: 9.14M]
  ------------------
   39|   127k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   127k|            return true;
   41|   127k|         }
   42|  9.14M|         return Default;
   43|  9.27M|      }
_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|   127k|      {
   38|   127k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 41.0k, False: 86.5k]
  ------------------
   39|  41.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  41.0k|            return true;
   41|  41.0k|         }
   42|  86.5k|         return Default;
   43|   127k|      }
_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|  86.5k|      {
   38|  86.5k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 43.5k, False: 42.9k]
  ------------------
   39|  43.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  43.5k|            return true;
   41|  43.5k|         }
   42|  42.9k|         return Default;
   43|  86.5k|      }
_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|  7.55k|      {
   38|  7.55k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.45k, False: 1.10k]
  ------------------
   39|  6.45k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.45k|            return true;
   41|  6.45k|         }
   42|  1.10k|         return Default;
   43|  7.55k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.83M|      {
   38|  7.83M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 161k, False: 7.67M]
  ------------------
   39|   161k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   161k|            return true;
   41|   161k|         }
   42|  7.67M|         return Default;
   43|  7.83M|      }
_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|   161k|      {
   38|   161k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 74.6k, False: 86.9k]
  ------------------
   39|  74.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  74.6k|            return true;
   41|  74.6k|         }
   42|  86.9k|         return Default;
   43|   161k|      }
_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.9k|      {
   38|  86.9k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 26.0k, False: 60.9k]
  ------------------
   39|  26.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  26.0k|            return true;
   41|  26.0k|         }
   42|  60.9k|         return Default;
   43|  86.9k|      }
_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.42k|      {
   38|  5.42k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.77k, False: 655]
  ------------------
   39|  4.77k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.77k|            return true;
   41|  4.77k|         }
   42|    655|         return Default;
   43|  5.42k|      }
_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.45M|      {
   38|  2.45M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.33k, False: 2.45M]
  ------------------
   39|  5.33k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.33k|            return true;
   41|  5.33k|         }
   42|  2.45M|         return Default;
   43|  2.45M|      }
_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|  5.33k|      {
   38|  5.33k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 1.52k, False: 3.80k]
  ------------------
   39|  1.52k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  1.52k|            return true;
   41|  1.52k|         }
   42|  3.80k|         return Default;
   43|  5.33k|      }
_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|  3.80k|      {
   38|  3.80k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 1.04k, False: 2.76k]
  ------------------
   39|  1.04k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  1.04k|            return true;
   41|  1.04k|         }
   42|  2.76k|         return Default;
   43|  3.80k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.45k|      {
   38|  6.45k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.39k, False: 1.06k]
  ------------------
   39|  5.39k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.39k|            return true;
   41|  5.39k|         }
   42|  1.06k|         return Default;
   43|  6.45k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.50M|      {
   38|  6.50M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 69.8k, False: 6.43M]
  ------------------
   39|  69.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  69.8k|            return true;
   41|  69.8k|         }
   42|  6.43M|         return Default;
   43|  6.50M|      }
_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|  69.8k|      {
   38|  69.8k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.5k, False: 39.3k]
  ------------------
   39|  30.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.5k|            return true;
   41|  30.5k|         }
   42|  39.3k|         return Default;
   43|  69.8k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  39.3k|      {
   38|  39.3k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 14.9k, False: 24.4k]
  ------------------
   39|  14.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  14.9k|            return true;
   41|  14.9k|         }
   42|  24.4k|         return Default;
   43|  39.3k|      }
_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.54k|      {
   38|  5.54k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.73k, False: 812]
  ------------------
   39|  4.73k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.73k|            return true;
   41|  4.73k|         }
   42|    812|         return Default;
   43|  5.54k|      }
_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.80M|      {
   38|  7.80M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 88.2k, False: 7.71M]
  ------------------
   39|  88.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  88.2k|            return true;
   41|  88.2k|         }
   42|  7.71M|         return Default;
   43|  7.80M|      }
_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|  88.2k|      {
   38|  88.2k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 20.7k, False: 67.4k]
  ------------------
   39|  20.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  20.7k|            return true;
   41|  20.7k|         }
   42|  67.4k|         return Default;
   43|  88.2k|      }
_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|  67.4k|      {
   38|  67.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 28.9k, False: 38.5k]
  ------------------
   39|  28.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  28.9k|            return true;
   41|  28.9k|         }
   42|  38.5k|         return Default;
   43|  67.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|   641k|      {
   38|   641k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 36.1k, False: 605k]
  ------------------
   39|  36.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  36.1k|            return true;
   41|  36.1k|         }
   42|   605k|         return Default;
   43|   641k|      }
_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|  45.0M|      {
   38|  45.0M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 186k, False: 44.8M]
  ------------------
   39|   186k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   186k|            return true;
   41|   186k|         }
   42|  44.8M|         return Default;
   43|  45.0M|      }
_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|   186k|      {
   38|   186k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 38.0k, False: 148k]
  ------------------
   39|  38.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  38.0k|            return true;
   41|  38.0k|         }
   42|   148k|         return Default;
   43|   186k|      }
_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|   148k|      {
   38|   148k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 36.0k, False: 112k]
  ------------------
   39|  36.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  36.0k|            return true;
   41|  36.0k|         }
   42|   112k|         return Default;
   43|   148k|      }
_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.08k|      {
   38|  7.08k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.24k, False: 832]
  ------------------
   39|  6.24k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.24k|            return true;
   41|  6.24k|         }
   42|    832|         return Default;
   43|  7.08k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  9.08M|      {
   38|  9.08M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 88.7k, False: 8.99M]
  ------------------
   39|  88.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  88.7k|            return true;
   41|  88.7k|         }
   42|  8.99M|         return Default;
   43|  9.08M|      }
_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|  88.7k|      {
   38|  88.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 32.9k, False: 55.7k]
  ------------------
   39|  32.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  32.9k|            return true;
   41|  32.9k|         }
   42|  55.7k|         return Default;
   43|  88.7k|      }
_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|  55.7k|      {
   38|  55.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 27.9k, False: 27.8k]
  ------------------
   39|  27.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  27.9k|            return true;
   41|  27.9k|         }
   42|  27.8k|         return Default;
   43|  55.7k|      }

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

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

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

_ZN3tao5pegtl8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEbRT3_DpOT4_:
   55|  10.3k|      {
   56|  10.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 10.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  10.3k|         return true;
   60|  10.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   316k|      {
   56|   316k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 207, False: 315k]
  ------------------
   57|    207|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    207|         }
   59|   316k|         return true;
   60|   316k|      }
_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|   239k|      {
   56|   239k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 65, False: 239k]
  ------------------
   57|     65|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     65|         }
   59|   239k|         return true;
   60|   239k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|   106k|      {
   56|   106k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 27, False: 106k]
  ------------------
   57|     27|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     27|         }
   59|   106k|         return true;
   60|   106k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  34.9k|      {
   56|  34.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 34.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  34.9k|         return true;
   60|  34.9k|      }
_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.54k|      {
   56|  7.54k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 201, False: 7.34k]
  ------------------
   57|    201|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    201|         }
   59|  7.54k|         return true;
   60|  7.54k|      }
_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|   127k|      {
   56|   127k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 58, False: 127k]
  ------------------
   57|     58|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     58|         }
   59|   127k|         return true;
   60|   127k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_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: 38, False: 40.9k]
  ------------------
   57|     38|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     38|         }
   59|  41.0k|         return true;
   60|  41.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|  43.5k|      {
   56|  43.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 43.5k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  43.5k|         return true;
   60|  43.5k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.45k|      {
   56|  6.45k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 164, False: 6.28k]
  ------------------
   57|    164|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    164|         }
   59|  6.45k|         return true;
   60|  6.45k|      }
_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|   161k|      {
   56|   161k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 55, False: 161k]
  ------------------
   57|     55|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     55|         }
   59|   161k|         return true;
   60|   161k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  74.6k|      {
   56|  74.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 37, False: 74.6k]
  ------------------
   57|     37|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     37|         }
   59|  74.6k|         return true;
   60|  74.6k|      }
_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|  26.0k|      {
   56|  26.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 26.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  26.0k|         return true;
   60|  26.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.77k|      {
   56|  4.77k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 162, False: 4.61k]
  ------------------
   57|    162|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    162|         }
   59|  4.77k|         return true;
   60|  4.77k|      }
_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|  5.33k|      {
   56|  5.33k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 26, False: 5.30k]
  ------------------
   57|     26|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     26|         }
   59|  5.33k|         return true;
   60|  5.33k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  1.52k|      {
   56|  1.52k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 26, False: 1.49k]
  ------------------
   57|     26|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     26|         }
   59|  1.52k|         return true;
   60|  1.52k|      }
_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.04k|      {
   56|  1.04k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 1.04k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  1.04k|         return true;
   60|  1.04k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.39k|      {
   56|  5.39k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 205, False: 5.19k]
  ------------------
   57|    205|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    205|         }
   59|  5.39k|         return true;
   60|  5.39k|      }
_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|  69.8k|      {
   56|  69.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 58, False: 69.8k]
  ------------------
   57|     58|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     58|         }
   59|  69.8k|         return true;
   60|  69.8k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  30.5k|      {
   56|  30.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 26, False: 30.4k]
  ------------------
   57|     26|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     26|         }
   59|  30.5k|         return true;
   60|  30.5k|      }
_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|  14.9k|      {
   56|  14.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 14.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  14.9k|         return true;
   60|  14.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.73k|      {
   56|  4.73k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 169, False: 4.56k]
  ------------------
   57|    169|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    169|         }
   59|  4.73k|         return true;
   60|  4.73k|      }
_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|  88.2k|      {
   56|  88.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 39, False: 88.2k]
  ------------------
   57|     39|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     39|         }
   59|  88.2k|         return true;
   60|  88.2k|      }
_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|  20.7k|      {
   56|  20.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 37, False: 20.7k]
  ------------------
   57|     37|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     37|         }
   59|  20.7k|         return true;
   60|  20.7k|      }
_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|  28.9k|      {
   56|  28.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 28.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  28.9k|         return true;
   60|  28.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  36.1k|      {
   56|  36.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 270, False: 35.8k]
  ------------------
   57|    270|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    270|         }
   59|  36.1k|         return true;
   60|  36.1k|      }
_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|   186k|      {
   56|   186k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 61, False: 186k]
  ------------------
   57|     61|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     61|         }
   59|   186k|         return true;
   60|   186k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  38.0k|      {
   56|  38.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 41, False: 37.9k]
  ------------------
   57|     41|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     41|         }
   59|  38.0k|         return true;
   60|  38.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  36.0k|      {
   56|  36.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 36.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  36.0k|         return true;
   60|  36.0k|      }
_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.24k|      {
   56|  6.24k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 198, False: 6.05k]
  ------------------
   57|    198|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    198|         }
   59|  6.24k|         return true;
   60|  6.24k|      }
_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|  88.7k|      {
   56|  88.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 58, False: 88.6k]
  ------------------
   57|     58|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     58|         }
   59|  88.7k|         return true;
   60|  88.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  32.9k|      {
   56|  32.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 47, False: 32.8k]
  ------------------
   57|     47|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     47|         }
   59|  32.9k|         return true;
   60|  32.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  27.9k|      {
   56|  27.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 27.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  27.9k|         return true;
   60|  27.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   55|  33.5k|      {
   56|  33.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.53k, False: 29.0k]
  ------------------
   57|  4.53k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.53k|         }
   59|  33.5k|         return true;
   60|  33.5k|      }

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

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  6.00M|      {
   41|  6.00M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 5.93M, False: 70.3k]
  ------------------
   42|  5.93M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 3.66M, False: 2.27M]
  ------------------
   43|  3.66M|               bump_help< one >( in, t.size );
   44|  3.66M|               return true;
   45|  3.66M|            }
   46|  5.93M|         }
   47|  2.34M|         return false;
   48|  6.00M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  5.93M|      {
   32|  8.27M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 3.59M, False: 2.33M]
  |  Branch (32:19): [True: 64.0k, False: 2.27M]
  ------------------
   33|  5.93M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  71.6k|      {
   41|  71.6k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 52.9k, False: 18.6k]
  ------------------
   42|  52.9k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 10.3k, False: 42.5k]
  ------------------
   43|  10.3k|               bump_help< one >( in, t.size );
   44|  10.3k|               return true;
   45|  10.3k|            }
   46|  52.9k|         }
   47|  61.2k|         return false;
   48|  71.6k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  52.9k|      {
   32|  52.9k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  52.9k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.90M|      {
   41|  1.90M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.90M, False: 936]
  ------------------
   42|  1.90M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.86M, False: 36.2k]
  ------------------
   43|  1.86M|               bump_help< one >( in, t.size );
   44|  1.86M|               return true;
   45|  1.86M|            }
   46|  1.90M|         }
   47|  37.1k|         return false;
   48|  1.90M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  1.90M|      {
   32|  1.90M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.90M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.18M|      {
   41|  1.18M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.18M, False: 45]
  ------------------
   42|  1.18M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.18M, False: 89]
  ------------------
   43|  1.18M|               bump_help< one >( in, t.size );
   44|  1.18M|               return true;
   45|  1.18M|            }
   46|  1.18M|         }
   47|    134|         return false;
   48|  1.18M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|  1.18M|      {
   32|  1.18M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.18M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  37.1k|      {
   41|  37.1k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 36.7k, False: 420]
  ------------------
   42|  36.7k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 24.7k, False: 11.9k]
  ------------------
   43|  24.7k|               bump_help< one >( in, t.size );
   44|  24.7k|               return true;
   45|  24.7k|            }
   46|  36.7k|         }
   47|  12.3k|         return false;
   48|  37.1k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  36.7k|      {
   32|  36.7k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  36.7k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  22.9k|      {
   41|  22.9k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 21.7k, False: 1.12k]
  ------------------
   42|  21.7k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 21.1k, False: 685]
  ------------------
   43|  21.1k|               bump_help< one >( in, t.size );
   44|  21.1k|               return true;
   45|  21.1k|            }
   46|  21.7k|         }
   47|  1.80k|         return false;
   48|  22.9k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  21.7k|      {
   32|  21.7k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  21.7k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  59.2M|      {
   41|  59.2M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 59.2M, False: 1.92k]
  ------------------
   42|  59.2M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 711k, False: 58.5M]
  ------------------
   43|   711k|               bump_help< one >( in, t.size );
   44|   711k|               return true;
   45|   711k|            }
   46|  59.2M|         }
   47|  58.5M|         return false;
   48|  59.2M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  59.2M|      {
   32|  59.2M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  59.2M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   103M|      {
   41|   103M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 103M, False: 1.54k]
  ------------------
   42|   103M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 967k, False: 102M]
  ------------------
   43|   967k|               bump_help< one >( in, t.size );
   44|   967k|               return true;
   45|   967k|            }
   46|   103M|         }
   47|   102M|         return false;
   48|   103M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|   103M|      {
   32|   103M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   103M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   967k|      {
   41|   967k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 967k, False: 106]
  ------------------
   42|   967k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 345k, False: 621k]
  ------------------
   43|   345k|               bump_help< one >( in, t.size );
   44|   345k|               return true;
   45|   345k|            }
   46|   967k|         }
   47|   621k|         return false;
   48|   967k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|   967k|      {
   32|   967k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   967k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   408k|      {
   41|   408k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 408k, False: 106]
  ------------------
   42|   408k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 397k, False: 11.3k]
  ------------------
   43|   397k|               bump_help< one >( in, t.size );
   44|   397k|               return true;
   45|   397k|            }
   46|   408k|         }
   47|  11.4k|         return false;
   48|   408k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   408k|      {
   32|  3.61M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 40.8k]
  |  Branch (32:19): [True: 29.5k, False: 11.3k]
  |  Branch (32:19): [True: 25.7k, False: 40.8k]
  |  Branch (32:19): [True: 50.9k, False: 66.6k]
  |  Branch (32:19): [True: 15.4k, False: 117k]
  |  Branch (32:19): [True: 21.5k, False: 133k]
  |  Branch (32:19): [True: 40.0k, False: 154k]
  |  Branch (32:19): [True: 29.0k, False: 194k]
  |  Branch (32:19): [True: 59.2k, False: 223k]
  |  Branch (32:19): [True: 83.0k, False: 283k]
  |  Branch (32:19): [True: 42.2k, False: 366k]
  ------------------
   33|   408k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   102M|      {
   41|   102M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 102M, False: 1.54k]
  ------------------
   42|   102M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 102M, False: 34]
  ------------------
   43|   102M|               bump_help< one >( in, t.size );
   44|   102M|               return true;
   45|   102M|            }
   46|   102M|         }
   47|  1.57k|         return false;
   48|   102M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|   102M|      {
   32|   205M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 19, False: 102M]
  |  Branch (32:19): [True: 15, False: 102M]
  ------------------
   33|   102M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   643k|      {
   41|   643k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 643k, False: 109]
  ------------------
   42|   643k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 498, False: 642k]
  ------------------
   43|    498|               bump_help< one >( in, t.size );
   44|    498|               return true;
   45|    498|            }
   46|   643k|         }
   47|   642k|         return false;
   48|   643k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   643k|      {
   32|   643k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   643k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   641k|      {
   41|   641k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 640k, False: 1.06k]
  ------------------
   42|   640k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 36.1k, False: 604k]
  ------------------
   43|  36.1k|               bump_help< one >( in, t.size );
   44|  36.1k|               return true;
   45|  36.1k|            }
   46|   640k|         }
   47|   605k|         return false;
   48|   641k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   640k|      {
   32|   640k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   640k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  45.0M|      {
   41|  45.0M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 45.0M, False: 272]
  ------------------
   42|  45.0M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 36.1k, False: 45.0M]
  ------------------
   43|  36.1k|               bump_help< one >( in, t.size );
   44|  36.1k|               return true;
   45|  36.1k|            }
   46|  45.0M|         }
   47|  45.0M|         return false;
   48|  45.0M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  45.0M|      {
   32|  45.0M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  45.0M|      }

_ZN3tao5pegtl8internal3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  38.1k|      {
   47|  38.1k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.1k|         return true;
   49|  38.1k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   46|  38.0k|      {
   47|  38.0k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.0k|         return true;
   49|  38.0k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   46|  38.0k|      {
   47|  38.0k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.0k|         return true;
   49|  38.0k|      }
_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.42k|      {
   47|  3.42k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.42k|         return true;
   49|  3.42k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.65k|      {
   47|  3.65k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.65k|         return true;
   49|  3.65k|      }
_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.14k|      {
   47|  4.14k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.14k|         return true;
   49|  4.14k|      }
_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.21k|      {
   47|  3.21k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.21k|         return true;
   49|  3.21k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  2.99k|      {
   47|  2.99k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.99k|         return true;
   49|  2.99k|      }
_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.21k|      {
   47|  3.21k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.21k|         return true;
   49|  3.21k|      }
_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.45k|      {
   47|  3.45k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.45k|         return true;
   49|  3.45k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  2.74k|      {
   47|  2.74k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.74k|         return true;
   49|  2.74k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  5.97k|      {
   47|  5.97k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  5.97k|         return true;
   49|  5.97k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   643k|      {
   47|   643k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   643k|         return true;
   49|   643k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   641k|      {
   47|   641k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   641k|         return true;
   49|   641k|      }
_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.34k|      {
   47|  4.34k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.34k|         return true;
   49|  4.34k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  33.4k|      {
   47|  33.4k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  33.4k|         return true;
   49|  33.4k|      }

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

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   104k|      {
   46|   104k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 78.7k, False: 26.1k]
  ------------------
   47|  83.9k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 5.27k, False: 78.7k]
  ------------------
   48|  5.27k|            }
   49|  78.7k|            return true;
   50|  78.7k|         }
   51|  26.1k|         return false;
   52|   104k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   856k|      {
   46|   856k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 855k, False: 1.10k]
  ------------------
   47|   861k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 5.96k, False: 855k]
  ------------------
   48|  5.96k|            }
   49|   855k|            return true;
   50|   855k|         }
   51|  1.10k|         return false;
   52|   856k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   320k|      {
   46|   320k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 318k, False: 1.86k]
  ------------------
   47|   321k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.08k, False: 318k]
  ------------------
   48|  3.08k|            }
   49|   318k|            return true;
   50|   318k|         }
   51|  1.86k|         return false;
   52|   320k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  11.9k|      {
   46|  11.9k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 10.0k, False: 1.93k]
  ------------------
   47|  11.9k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.91k, False: 10.0k]
  ------------------
   48|  1.91k|            }
   49|  10.0k|            return true;
   50|  10.0k|         }
   51|  1.93k|         return false;
   52|  11.9k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.0k|      {
   46|  10.0k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.62k, False: 1.40k]
  ------------------
   47|  10.4k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.80k, False: 8.62k]
  ------------------
   48|  1.80k|            }
   49|  8.62k|            return true;
   50|  8.62k|         }
   51|  1.40k|         return false;
   52|  10.0k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.39k|      {
   46|  8.39k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.86k, False: 1.53k]
  ------------------
   47|  9.93k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.06k, False: 6.86k]
  ------------------
   48|  3.06k|            }
   49|  6.86k|            return true;
   50|  6.86k|         }
   51|  1.53k|         return false;
   52|  8.39k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_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.46k, False: 1.43k]
  ------------------
   47|  10.1k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.69k, False: 7.46k]
  ------------------
   48|  2.69k|            }
   49|  7.46k|            return true;
   50|  7.46k|         }
   51|  1.43k|         return false;
   52|  8.89k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   168k|      {
   46|   168k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 166k, False: 1.87k]
  ------------------
   47|  1.61M|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.44M, False: 166k]
  ------------------
   48|  1.44M|            }
   49|   166k|            return true;
   50|   166k|         }
   51|  1.87k|         return false;
   52|   168k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.13k|      {
   46|  8.13k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.59k, False: 1.54k]
  ------------------
   47|  9.98k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.39k, False: 6.59k]
  ------------------
   48|  3.39k|            }
   49|  6.59k|            return true;
   50|  6.59k|         }
   51|  1.54k|         return false;
   52|  8.13k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   645k|      {
   46|   645k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 643k, False: 2.09k]
  ------------------
   47|   672k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 28.9k, False: 643k]
  ------------------
   48|  28.9k|            }
   49|   643k|            return true;
   50|   643k|         }
   51|  2.09k|         return false;
   52|   645k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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: 8.62k, False: 2.14k]
  ------------------
   47|  10.4k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.79k, False: 8.62k]
  ------------------
   48|  1.79k|            }
   49|  8.62k|            return true;
   50|  8.62k|         }
   51|  2.14k|         return false;
   52|  10.7k|      }

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

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  3.27M|      {
   60|  3.27M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 3.27M, False: 1.22k]
  ------------------
   61|  3.27M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 1.37M, False: 1.90M]
  ------------------
   62|  1.37M|               bump_help< ranges >( in, t.size );
   63|  1.37M|               return true;
   64|  1.37M|            }
   65|  3.27M|         }
   66|  1.90M|         return false;
   67|  3.27M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  3.27M|      {
   51|  3.27M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  3.27M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  3.27M|      {
   40|  3.27M|         constexpr const data_t cs[] = { Cs... };
   41|  3.27M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|  11.8M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 389k, False: 2.58M]
  |  Branch (42:22): [True: 681k, False: 1.90M]
  |  Branch (42:22): [True: 306k, False: 2.97M]
  ------------------
   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.27M|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc48ETnS3_Lc57EEEbS3_:
   23|  3.95M|   {
   24|  3.95M|      static_assert( Lo <= Hi, "invalid range" );
   25|  3.95M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 1.41M, False: 2.54M]
  |  Branch (25:29): [True: 310k, False: 1.10M]
  ------------------
   26|  3.95M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc102EEEbS3_:
   23|  2.97M|   {
   24|  2.97M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.97M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 425k, False: 2.54M]
  |  Branch (25:29): [True: 389k, False: 35.9k]
  ------------------
   26|  2.97M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc70EEEbS3_:
   23|  2.58M|   {
   24|  2.58M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.58M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 717k, False: 1.86M]
  |  Branch (25:29): [True: 681k, False: 36.0k]
  ------------------
   26|  2.58M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   643k|      {
   60|   643k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 643k, False: 117]
  ------------------
   61|   643k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 641k, False: 1.17k]
  ------------------
   62|   641k|               bump_help< ranges >( in, t.size );
   63|   641k|               return true;
   64|   641k|            }
   65|   643k|         }
   66|  1.29k|         return false;
   67|   643k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   643k|      {
   51|   643k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   643k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   643k|      {
   40|   643k|         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|   643k|         else {
   45|  1.28M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 641k, False: 1.26k]
  |  Branch (45:22): [True: 51, False: 1.21k]
  |  Branch (45:96): [True: 34, False: 1.17k]
  ------------------
   46|   643k|         }
   47|   643k|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc122EEEbS3_:
   23|  30.1M|   {
   24|  30.1M|      static_assert( Lo <= Hi, "invalid range" );
   25|  30.1M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.21M, False: 24.8M]
  |  Branch (25:29): [True: 5.20M, False: 2.54k]
  ------------------
   26|  30.1M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc90EEEbS3_:
   23|  24.8M|   {
   24|  24.8M|      static_assert( Lo <= Hi, "invalid range" );
   25|  24.8M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 24.2M, False: 678k]
  |  Branch (25:29): [True: 24.2M, False: 2.55k]
  ------------------
   26|  24.8M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  29.4M|      {
   60|  29.4M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 29.4M, False: 1.06k]
  ------------------
   61|  29.4M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 28.8M, False: 640k]
  ------------------
   62|  28.8M|               bump_help< ranges >( in, t.size );
   63|  28.8M|               return true;
   64|  28.8M|            }
   65|  29.4M|         }
   66|   641k|         return false;
   67|  29.4M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  29.4M|      {
   51|  29.4M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  29.4M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  29.4M|      {
   40|  29.4M|         constexpr const data_t cs[] = { Cs... };
   41|       |         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|       |            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
   43|       |         }
   44|  29.4M|         else {
   45|   109M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 24.2M, False: 680k]
  |  Branch (45:22): [True: 3.93k, False: 676k]
  |  Branch (45:22): [True: 4.56M, False: 24.8M]
  |  Branch (45:96): [True: 35.3k, False: 640k]
  ------------------
   46|  29.4M|         }
   47|  29.4M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  40.5k|      {
   50|  40.5k|         auto m = in.template mark< M >();
   51|  40.5k|         using m_t = decltype( m );
   52|       |
   53|  52.6k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 49.6k, False: 3.00k]
  ------------------
   54|  49.6k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 37.5k, False: 12.1k]
  ------------------
   55|  37.5k|               return false;
   56|  37.5k|            }
   57|  49.6k|         }
   58|  3.00k|         return m( true );
   59|  40.5k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.70M|      {
   50|  1.70M|         auto m = in.template mark< M >();
   51|  1.70M|         using m_t = decltype( m );
   52|       |
   53|  1.71M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.71M, False: 1.74k]
  ------------------
   54|  1.71M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.70M, False: 7.11k]
  ------------------
   55|  1.70M|               return false;
   56|  1.70M|            }
   57|  1.71M|         }
   58|  1.74k|         return m( true );
   59|  1.70M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   106k|      {
   50|   106k|         auto m = in.template mark< M >();
   51|   106k|         using m_t = decltype( m );
   52|       |
   53|   318k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 212k, False: 106k]
  ------------------
   54|   212k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 27, False: 212k]
  ------------------
   55|     27|               return false;
   56|     27|            }
   57|   212k|         }
   58|   106k|         return m( true );
   59|   106k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  41.0k|      {
   50|  41.0k|         auto m = in.template mark< M >();
   51|  41.0k|         using m_t = decltype( m );
   52|       |
   53|   123k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 82.0k, False: 40.9k]
  ------------------
   54|  82.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 38, False: 82.0k]
  ------------------
   55|     38|               return false;
   56|     38|            }
   57|  82.0k|         }
   58|  40.9k|         return m( true );
   59|  41.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  74.6k|      {
   50|  74.6k|         auto m = in.template mark< M >();
   51|  74.6k|         using m_t = decltype( m );
   52|       |
   53|   224k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 149k, False: 74.6k]
  ------------------
   54|   149k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 37, False: 149k]
  ------------------
   55|     37|               return false;
   56|     37|            }
   57|   149k|         }
   58|  74.6k|         return m( true );
   59|  74.6k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.52k|      {
   50|  1.52k|         auto m = in.template mark< M >();
   51|  1.52k|         using m_t = decltype( m );
   52|       |
   53|  4.53k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 3.03k, False: 1.49k]
  ------------------
   54|  3.03k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 26, False: 3.00k]
  ------------------
   55|     26|               return false;
   56|     26|            }
   57|  3.03k|         }
   58|  1.49k|         return m( true );
   59|  1.52k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  30.5k|      {
   50|  30.5k|         auto m = in.template mark< M >();
   51|  30.5k|         using m_t = decltype( m );
   52|       |
   53|  91.4k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 61.0k, False: 30.4k]
  ------------------
   54|  61.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 26, False: 60.9k]
  ------------------
   55|     26|               return false;
   56|     26|            }
   57|  61.0k|         }
   58|  30.4k|         return m( true );
   59|  30.5k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   165k|      {
   50|   165k|         auto m = in.template mark< M >();
   51|   165k|         using m_t = decltype( m );
   52|       |
   53|   493k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 329k, False: 164k]
  ------------------
   54|   329k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.12k, False: 328k]
  ------------------
   55|  1.12k|               return false;
   56|  1.12k|            }
   57|   329k|         }
   58|   164k|         return m( true );
   59|   165k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   327k|      {
   50|   327k|         auto m = in.template mark< M >();
   51|   327k|         using m_t = decltype( m );
   52|       |
   53|   666k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 497k, False: 169k]
  ------------------
   54|   497k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 158k, False: 338k]
  ------------------
   55|   158k|               return false;
   56|   158k|            }
   57|   497k|         }
   58|   169k|         return m( true );
   59|   327k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  20.7k|      {
   50|  20.7k|         auto m = in.template mark< M >();
   51|  20.7k|         using m_t = decltype( m );
   52|       |
   53|  62.2k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 41.5k, False: 20.7k]
  ------------------
   54|  41.5k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 37, False: 41.5k]
  ------------------
   55|     37|               return false;
   56|     37|            }
   57|  41.5k|         }
   58|  20.7k|         return m( true );
   59|  20.7k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  38.0k|      {
   50|  38.0k|         auto m = in.template mark< M >();
   51|  38.0k|         using m_t = decltype( m );
   52|       |
   53|   113k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 75.9k, False: 37.9k]
  ------------------
   54|  75.9k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41, False: 75.9k]
  ------------------
   55|     41|               return false;
   56|     41|            }
   57|  75.9k|         }
   58|  37.9k|         return m( true );
   59|  38.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  32.9k|      {
   50|  32.9k|         auto m = in.template mark< M >();
   51|  32.9k|         using m_t = decltype( m );
   52|       |
   53|  98.6k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 65.8k, False: 32.8k]
  ------------------
   54|  65.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 47, False: 65.7k]
  ------------------
   55|     47|               return false;
   56|     47|            }
   57|  65.8k|         }
   58|  32.8k|         return m( true );
   59|  32.9k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  34.9k|      {
   50|  42.3k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 39.9k, False: 2.35k]
  |  Branch (50:47): [True: 7.39k, False: 32.5k]
  ------------------
   51|  7.39k|         }
   52|  34.9k|         return true;
   53|  34.9k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  43.5k|      {
   50|  52.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 48.7k, False: 4.01k]
  |  Branch (50:47): [True: 9.19k, False: 39.5k]
  ------------------
   51|  9.19k|         }
   52|  43.5k|         return true;
   53|  43.5k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  26.0k|      {
   50|  41.4k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 34.6k, False: 6.76k]
  |  Branch (50:47): [True: 15.4k, False: 19.2k]
  ------------------
   51|  15.4k|         }
   52|  26.0k|         return true;
   53|  26.0k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.04k|      {
   50|  1.77k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 1.45k, False: 312]
  |  Branch (50:47): [True: 728, False: 730]
  ------------------
   51|    728|         }
   52|  1.04k|         return true;
   53|  1.04k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  14.9k|      {
   50|  22.9k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 19.6k, False: 3.30k]
  |  Branch (50:47): [True: 8.04k, False: 11.6k]
  ------------------
   51|  8.04k|         }
   52|  14.9k|         return true;
   53|  14.9k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  28.9k|      {
   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: 32.6k, False: 1.09k]
  |  Branch (50:47): [True: 4.80k, False: 27.8k]
  ------------------
   51|  4.80k|         }
   52|  28.9k|         return true;
   53|  28.9k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  36.0k|      {
   50|  46.0k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 43.4k, False: 2.53k]
  |  Branch (50:47): [True: 10.0k, False: 33.4k]
  ------------------
   51|  10.0k|         }
   52|  36.0k|         return true;
   53|  36.0k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  27.9k|      {
   50|  34.8k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 32.2k, False: 2.61k]
  |  Branch (50:47): [True: 6.90k, False: 25.3k]
  ------------------
   51|  6.90k|         }
   52|  27.9k|         return true;
   53|  27.9k|      }

_ZN3tao5pegtl8internal3seqIJNS0_4starINS0_5ascii5blankEJEEENS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENSA_4ruleEEEEEEENS0_4mustIJNS0_3eofEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSS_11char_traitsIcEENSS_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   41|  38.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.1k|         else {
   46|  38.1k|            auto m = in.template mark< M >();
   47|  38.1k|            using m_t = decltype( m );
   48|   148k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 33.5k, False: 4.60k]
  |  Branch (48:25): [True: 29.0k, False: 4.53k]
  |  Branch (48:25): [True: 38.1k, False: 0]
  ------------------
   49|  38.1k|         }
   50|  38.1k|      }
_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|  71.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  71.6k|         else {
   46|  71.6k|            auto m = in.template mark< M >();
   47|  71.6k|            using m_t = decltype( m );
   48|   143k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 71.6k, False: 0]
  |  Branch (48:25): [True: 10.3k, False: 61.2k]
  ------------------
   49|  71.6k|         }
   50|  71.6k|      }
_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|   331k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   331k|         else {
   46|   331k|            auto m = in.template mark< M >();
   47|   331k|            using m_t = decltype( m );
   48|   652k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 320k, False: 10.3k]
  |  Branch (48:25): [True: 320k, False: 0]
  ------------------
   49|   331k|         }
   50|   331k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6targetENS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS4_9device_idEEEENS6_IJSA_NS0_4listINS4_15rule_attributesESA_vEEEEENS6_IJNS4_7commentEEEENS0_4starIS9_JEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSV_11char_traitsIcEENSV_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.1k|         else {
   46|  38.1k|            auto m = in.template mark< M >();
   47|  38.1k|            using m_t = decltype( m );
   48|   290k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 33.4k, False: 0]
  |  Branch (48:25): [True: 33.4k, False: 0]
  |  Branch (48:25): [True: 33.4k, False: 4.60k]
  |  Branch (48:25): [True: 38.0k, False: 4]
  |  Branch (48:25): [True: 38.0k, False: 103]
  ------------------
   49|  38.1k|         }
   50|  38.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  38.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.0k|         else {
   46|  38.0k|            auto m = in.template mark< M >();
   47|  38.0k|            using m_t = decltype( m );
   48|  76.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 38.0k, False: 30]
  |  Branch (48:25): [True: 2.49k, False: 35.5k]
  ------------------
   49|  38.0k|         }
   50|  38.0k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10device_vidENS0_5ascii3oneIJLc58EEEENS4_10device_pidEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.0k|         else {
   46|  38.0k|            auto m = in.template mark< M >();
   47|  38.0k|            using m_t = decltype( m );
   48|  45.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.51k, False: 23]
  |  Branch (48:25): [True: 2.50k, False: 10]
  |  Branch (48:25): [True: 2.53k, False: 35.4k]
  ------------------
   49|  38.0k|         }
   50|  38.0k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   41|  38.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.0k|         else {
   46|  38.0k|            auto m = in.template mark< M >();
   47|  38.0k|            using m_t = decltype( m );
   48|  73.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 35.9k, False: 2.08k]
  |  Branch (48:25): [True: 25.3k, False: 10.6k]
  ------------------
   49|  38.0k|         }
   50|  38.0k|      }
_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|  35.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  35.9k|         else {
   46|  35.9k|            auto m = in.template mark< M >();
   47|  35.9k|            using m_t = decltype( m );
   48|  61.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 25.6k, False: 10.3k]
  |  Branch (48:25): [True: 25.3k, False: 287]
  ------------------
   49|  35.9k|         }
   50|  35.9k|      }
_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|  40.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  40.6k|         else {
   46|  40.6k|            auto m = in.template mark< M >();
   47|  40.6k|            using m_t = decltype( m );
   48|  51.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.42k, False: 21]
  |  Branch (48:25): [True: 2.96k, False: 459]
  |  Branch (48:25): [True: 3.44k, False: 37.2k]
  ------------------
   49|  40.6k|         }
   50|  40.6k|      }
_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.42k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.42k|         else {
   46|  3.42k|            auto m = in.template mark< M >();
   47|  3.42k|            using m_t = decltype( m );
   48|  25.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.18k, False: 0]
  |  Branch (48:25): [True: 2.02k, False: 155]
  |  Branch (48:25): [True: 2.18k, False: 75]
  |  Branch (48:25): [True: 2.25k, False: 0]
  |  Branch (48:25): [True: 2.25k, False: 1.16k]
  |  Branch (48:25): [True: 3.42k, False: 0]
  ------------------
   49|  3.42k|         }
   50|  3.42k|      }
_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.42k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.42k|         else {
   46|  3.42k|            auto m = in.template mark< M >();
   47|  3.42k|            using m_t = decltype( m );
   48|  5.07k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.65k, False: 1.77k]
  |  Branch (48:25): [True: 1.61k, False: 43]
  ------------------
   49|  3.42k|         }
   50|  3.42k|      }
_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.25k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.25k|         else {
   46|  2.25k|            auto m = in.template mark< M >();
   47|  2.25k|            using m_t = decltype( m );
   48|  4.44k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.18k, False: 72]
  |  Branch (48:25): [True: 2.18k, False: 3]
  ------------------
   49|  2.25k|         }
   50|  2.25k|      }
_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|   851k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   851k|         else {
   46|   851k|            auto m = in.template mark< M >();
   47|   851k|            using m_t = decltype( m );
   48|  1.70M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 850k, False: 1.03k]
  |  Branch (48:25): [True: 849k, False: 1.14k]
  ------------------
   49|   851k|         }
   50|   851k|      }
_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|   854k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   854k|         else {
   46|   854k|            auto m = in.template mark< M >();
   47|   854k|            using m_t = decltype( m );
   48|  3.41M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 852k, False: 51]
  |  Branch (48:25): [True: 852k, False: 17]
  |  Branch (48:25): [True: 852k, False: 1.59k]
  ------------------
   49|   854k|         }
   50|   854k|      }
_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|  37.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  37.7k|         else {
   46|  37.7k|            auto m = in.template mark< M >();
   47|  37.7k|            using m_t = decltype( m );
   48|  48.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.65k, False: 16]
  |  Branch (48:25): [True: 2.94k, False: 714]
  |  Branch (48:25): [True: 3.67k, False: 34.0k]
  ------------------
   49|  37.7k|         }
   50|  37.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.65k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.65k|         else {
   46|  3.65k|            auto m = in.template mark< M >();
   47|  3.65k|            using m_t = decltype( m );
   48|  28.2k|            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.28k, False: 143]
  |  Branch (48:25): [True: 2.42k, False: 69]
  |  Branch (48:25): [True: 2.49k, False: 0]
  |  Branch (48:25): [True: 2.49k, False: 1.16k]
  |  Branch (48:25): [True: 3.65k, False: 0]
  ------------------
   49|  3.65k|         }
   50|  3.65k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.65k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.65k|         else {
   46|  3.65k|            auto m = in.template mark< M >();
   47|  3.65k|            using m_t = decltype( m );
   48|  5.34k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.68k, False: 1.96k]
  |  Branch (48:25): [True: 1.64k, False: 40]
  ------------------
   49|  3.65k|         }
   50|  3.65k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.49k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.49k|         else {
   46|  2.49k|            auto m = in.template mark< M >();
   47|  2.49k|            using m_t = decltype( m );
   48|  4.93k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.44k, False: 51]
  |  Branch (48:25): [True: 2.42k, False: 18]
  ------------------
   49|  2.49k|         }
   50|  2.49k|      }
_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|   315k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   315k|         else {
   46|   315k|            auto m = in.template mark< M >();
   47|   315k|            using m_t = decltype( m );
   48|   628k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 313k, False: 1.80k]
  |  Branch (48:25): [True: 312k, False: 637]
  ------------------
   49|   315k|         }
   50|   315k|      }
_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|  34.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  34.3k|         else {
   46|  34.3k|            auto m = in.template mark< M >();
   47|  34.3k|            using m_t = decltype( m );
   48|  46.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.14k, False: 18]
  |  Branch (48:25): [True: 3.42k, False: 722]
  |  Branch (48:25): [True: 4.16k, False: 30.2k]
  ------------------
   49|  34.3k|         }
   50|  34.3k|      }
_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.14k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.14k|         else {
   46|  4.14k|            auto m = in.template mark< M >();
   47|  4.14k|            using m_t = decltype( m );
   48|  31.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.71k, False: 0]
  |  Branch (48:25): [True: 2.58k, False: 128]
  |  Branch (48:25): [True: 2.71k, False: 89]
  |  Branch (48:25): [True: 2.80k, False: 0]
  |  Branch (48:25): [True: 2.80k, False: 1.34k]
  |  Branch (48:25): [True: 4.14k, False: 0]
  ------------------
   49|  4.14k|         }
   50|  4.14k|      }
_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.14k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.14k|         else {
   46|  4.14k|            auto m = in.template mark< M >();
   47|  4.14k|            using m_t = decltype( m );
   48|  5.62k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.47k, False: 2.67k]
  |  Branch (48:25): [True: 1.43k, False: 40]
  ------------------
   49|  4.14k|         }
   50|  4.14k|      }
_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.80k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.80k|         else {
   46|  2.80k|            auto m = in.template mark< M >();
   47|  2.80k|            using m_t = decltype( m );
   48|  5.53k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.73k, False: 66]
  |  Branch (48:25): [True: 2.71k, False: 23]
  ------------------
   49|  2.80k|         }
   50|  2.80k|      }
_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.33k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.33k|         else {
   46|  6.33k|            auto m = in.template mark< M >();
   47|  6.33k|            using m_t = decltype( m );
   48|  10.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.46k, False: 1.87k]
  |  Branch (48:25): [True: 3.59k, False: 862]
  ------------------
   49|  6.33k|         }
   50|  6.33k|      }
_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|  30.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  30.5k|         else {
   46|  30.5k|            auto m = in.template mark< M >();
   47|  30.5k|            using m_t = decltype( m );
   48|  40.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.21k, False: 13]
  |  Branch (48:25): [True: 2.58k, False: 628]
  |  Branch (48:25): [True: 3.22k, False: 27.3k]
  ------------------
   49|  30.5k|         }
   50|  30.5k|      }
_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.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.21k|         else {
   46|  3.21k|            auto m = in.template mark< M >();
   47|  3.21k|            using m_t = decltype( m );
   48|  24.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.09k, False: 0]
  |  Branch (48:25): [True: 1.97k, False: 124]
  |  Branch (48:25): [True: 2.09k, False: 79]
  |  Branch (48:25): [True: 2.17k, False: 0]
  |  Branch (48:25): [True: 2.17k, False: 1.04k]
  |  Branch (48:25): [True: 3.21k, False: 0]
  ------------------
   49|  3.21k|         }
   50|  3.21k|      }
_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.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.21k|         else {
   46|  3.21k|            auto m = in.template mark< M >();
   47|  3.21k|            using m_t = decltype( m );
   48|  4.49k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.27k, False: 1.94k]
  |  Branch (48:25): [True: 1.23k, False: 41]
  ------------------
   49|  3.21k|         }
   50|  3.21k|      }
_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.17k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.17k|         else {
   46|  2.17k|            auto m = in.template mark< M >();
   47|  2.17k|            using m_t = decltype( m );
   48|  4.28k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.11k, False: 61]
  |  Branch (48:25): [True: 2.09k, False: 18]
  ------------------
   49|  2.17k|         }
   50|  2.17k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  5.52k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.52k|         else {
   46|  5.52k|            auto m = in.template mark< M >();
   47|  5.52k|            using m_t = decltype( m );
   48|  9.69k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.17k, False: 1.35k]
  |  Branch (48:25): [True: 3.41k, False: 760]
  ------------------
   49|  5.52k|         }
   50|  5.52k|      }
_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|  27.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  27.6k|         else {
   46|  27.6k|            auto m = in.template mark< M >();
   47|  27.6k|            using m_t = decltype( m );
   48|  36.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.99k, False: 15]
  |  Branch (48:25): [True: 2.53k, False: 462]
  |  Branch (48:25): [True: 3.00k, False: 24.6k]
  ------------------
   49|  27.6k|         }
   50|  27.6k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  2.99k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.99k|         else {
   46|  2.99k|            auto m = in.template mark< M >();
   47|  2.99k|            using m_t = decltype( m );
   48|  22.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.87k, False: 0]
  |  Branch (48:25): [True: 1.77k, False: 98]
  |  Branch (48:25): [True: 1.87k, False: 48]
  |  Branch (48:25): [True: 1.91k, False: 0]
  |  Branch (48:25): [True: 1.91k, False: 1.07k]
  |  Branch (48:25): [True: 2.99k, False: 0]
  ------------------
   49|  2.99k|         }
   50|  2.99k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.99k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.99k|         else {
   46|  2.99k|            auto m = in.template mark< M >();
   47|  2.99k|            using m_t = decltype( m );
   48|  4.59k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.60k, False: 1.39k]
  |  Branch (48:25): [True: 1.56k, False: 33]
  ------------------
   49|  2.99k|         }
   50|  2.99k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  1.91k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.91k|         else {
   46|  1.91k|            auto m = in.template mark< M >();
   47|  1.91k|            using m_t = decltype( m );
   48|  3.79k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.88k, False: 37]
  |  Branch (48:25): [True: 1.87k, False: 11]
  ------------------
   49|  1.91k|         }
   50|  1.91k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  3.78k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.78k|         else {
   46|  3.78k|            auto m = in.template mark< M >();
   47|  3.78k|            using m_t = decltype( m );
   48|  6.09k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.30k, False: 1.48k]
  |  Branch (48:25): [True: 1.90k, False: 399]
  ------------------
   49|  3.78k|         }
   50|  3.78k|      }
_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|  24.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  24.9k|         else {
   46|  24.9k|            auto m = in.template mark< M >();
   47|  24.9k|            using m_t = decltype( m );
   48|  34.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.21k, False: 16]
  |  Branch (48:25): [True: 2.54k, False: 664]
  |  Branch (48:25): [True: 3.22k, False: 21.6k]
  ------------------
   49|  24.9k|         }
   50|  24.9k|      }
_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.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.21k|         else {
   46|  3.21k|            auto m = in.template mark< M >();
   47|  3.21k|            using m_t = decltype( m );
   48|  24.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.05k, False: 0]
  |  Branch (48:25): [True: 1.92k, False: 129]
  |  Branch (48:25): [True: 2.05k, False: 71]
  |  Branch (48:25): [True: 2.12k, False: 0]
  |  Branch (48:25): [True: 2.12k, False: 1.08k]
  |  Branch (48:25): [True: 3.21k, False: 0]
  ------------------
   49|  3.21k|         }
   50|  3.21k|      }
_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.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.21k|         else {
   46|  3.21k|            auto m = in.template mark< M >();
   47|  3.21k|            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.22k, False: 1.98k]
  |  Branch (48:25): [True: 1.18k, False: 47]
  ------------------
   49|  3.21k|         }
   50|  3.21k|      }
_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.12k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.12k|         else {
   46|  2.12k|            auto m = in.template mark< M >();
   47|  2.12k|            using m_t = decltype( m );
   48|  4.19k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.06k, False: 61]
  |  Branch (48:25): [True: 2.05k, False: 10]
  ------------------
   49|  2.12k|         }
   50|  2.12k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.44k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.44k|         else {
   46|  4.44k|            auto m = in.template mark< M >();
   47|  4.44k|            using m_t = decltype( m );
   48|  7.51k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.07k, False: 1.37k]
  |  Branch (48:25): [True: 2.37k, False: 694]
  ------------------
   49|  4.44k|         }
   50|  4.44k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser18str_with_interfaceENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_15interface_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  22.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  22.0k|         else {
   46|  22.0k|            auto m = in.template mark< M >();
   47|  22.0k|            using m_t = decltype( m );
   48|  32.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.45k, False: 6]
  |  Branch (48:25): [True: 2.99k, False: 462]
  |  Branch (48:25): [True: 3.46k, False: 18.5k]
  ------------------
   49|  22.0k|         }
   50|  22.0k|      }
_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.45k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.45k|         else {
   46|  3.45k|            auto m = in.template mark< M >();
   47|  3.45k|            using m_t = decltype( m );
   48|  28.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.55k, False: 0]
  |  Branch (48:25): [True: 2.36k, False: 189]
  |  Branch (48:25): [True: 2.55k, False: 52]
  |  Branch (48:25): [True: 2.60k, False: 0]
  |  Branch (48:25): [True: 2.60k, False: 853]
  |  Branch (48:25): [True: 3.45k, False: 0]
  ------------------
   49|  3.45k|         }
   50|  3.45k|      }
_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.45k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.45k|         else {
   46|  3.45k|            auto m = in.template mark< M >();
   47|  3.45k|            using m_t = decltype( m );
   48|  5.50k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.05k, False: 1.40k]
  |  Branch (48:25): [True: 2.01k, False: 41]
  ------------------
   49|  3.45k|         }
   50|  3.45k|      }
_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.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.15k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.55k, False: 50]
  |  Branch (48:25): [True: 2.55k, False: 2]
  ------------------
   49|  2.60k|         }
   50|  2.60k|      }
_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|   163k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   163k|         else {
   46|   163k|            auto m = in.template mark< M >();
   47|   163k|            using m_t = decltype( m );
   48|   324k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 161k, False: 1.82k]
  |  Branch (48:25): [True: 160k, False: 726]
  ------------------
   49|   163k|         }
   50|   163k|      }
_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|   165k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   165k|         else {
   46|   165k|            auto m = in.template mark< M >();
   47|   165k|            using m_t = decltype( m );
   48|  1.31M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 163k, False: 24]
  |  Branch (48:25): [True: 163k, False: 23]
  |  Branch (48:25): [True: 163k, False: 26]
  |  Branch (48:25): [True: 164k, False: 36]
  |  Branch (48:25): [True: 164k, False: 1.12k]
  ------------------
   49|   165k|         }
   50|   165k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser21str_with_connect_typeENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  19.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  19.0k|         else {
   46|  19.0k|            auto m = in.template mark< M >();
   47|  19.0k|            using m_t = decltype( m );
   48|  27.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.74k, False: 9]
  |  Branch (48:25): [True: 2.17k, False: 575]
  |  Branch (48:25): [True: 2.75k, False: 16.2k]
  ------------------
   49|  19.0k|         }
   50|  19.0k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  2.74k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.74k|         else {
   46|  2.74k|            auto m = in.template mark< M >();
   47|  2.74k|            using m_t = decltype( m );
   48|  22.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.98k, False: 0]
  |  Branch (48:25): [True: 1.86k, False: 116]
  |  Branch (48:25): [True: 1.98k, False: 73]
  |  Branch (48:25): [True: 2.05k, False: 0]
  |  Branch (48:25): [True: 2.05k, False: 693]
  |  Branch (48:25): [True: 2.74k, False: 0]
  ------------------
   49|  2.74k|         }
   50|  2.74k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.74k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.74k|         else {
   46|  2.74k|            auto m = in.template mark< M >();
   47|  2.74k|            using m_t = decltype( m );
   48|  3.99k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.24k, False: 1.50k]
  |  Branch (48:25): [True: 1.20k, False: 43]
  ------------------
   49|  2.74k|         }
   50|  2.74k|      }
_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.05k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.05k|         else {
   46|  2.05k|            auto m = in.template mark< M >();
   47|  2.05k|            using m_t = decltype( m );
   48|  4.04k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.99k, False: 63]
  |  Branch (48:25): [True: 1.98k, False: 10]
  ------------------
   49|  2.05k|         }
   50|  2.05k|      }
_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.13k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.13k|         else {
   46|  4.13k|            auto m = in.template mark< M >();
   47|  4.13k|            using m_t = decltype( m );
   48|  6.78k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.64k, False: 1.49k]
  |  Branch (48:25): [True: 2.14k, False: 499]
  ------------------
   49|  4.13k|         }
   50|  4.13k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6str_ifENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_9conditionEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  16.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  16.5k|         else {
   46|  16.5k|            auto m = in.template mark< M >();
   47|  16.5k|            using m_t = decltype( m );
   48|  34.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.97k, False: 27]
  |  Branch (48:25): [True: 2.95k, False: 3.02k]
  |  Branch (48:25): [True: 5.99k, False: 10.5k]
  ------------------
   49|  16.5k|         }
   50|  16.5k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_9conditionESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  5.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.97k|         else {
   46|  5.97k|            auto m = in.template mark< M >();
   47|  5.97k|            using m_t = decltype( m );
   48|  40.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: 1.92k, False: 603]
  |  Branch (48:25): [True: 2.52k, False: 1.23k]
  |  Branch (48:25): [True: 3.75k, False: 0]
  |  Branch (48:25): [True: 3.75k, False: 2.21k]
  |  Branch (48:25): [True: 5.97k, False: 0]
  ------------------
   49|  5.97k|         }
   50|  5.97k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  5.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.97k|         else {
   46|  5.97k|            auto m = in.template mark< M >();
   47|  5.97k|            using m_t = decltype( m );
   48|  7.29k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.32k, False: 4.65k]
  |  Branch (48:25): [True: 1.23k, False: 89]
  ------------------
   49|  5.97k|         }
   50|  5.97k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9conditionENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.75k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.75k|         else {
   46|  3.75k|            auto m = in.template mark< M >();
   47|  3.75k|            using m_t = decltype( m );
   48|  7.37k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.61k, False: 134]
  |  Branch (48:25): [True: 2.52k, False: 1.09k]
  ------------------
   49|  3.75k|         }
   50|  3.75k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   638k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   638k|         else {
   46|   638k|            auto m = in.template mark< M >();
   47|   638k|            using m_t = decltype( m );
   48|  1.27M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 636k, False: 1.98k]
  |  Branch (48:25): [True: 635k, False: 1.63k]
  ------------------
   49|   638k|         }
   50|   638k|      }
_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|   643k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   643k|         else {
   46|   643k|            auto m = in.template mark< M >();
   47|   643k|            using m_t = decltype( m );
   48|  2.57M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 641k, False: 1.29k]
  |  Branch (48:25): [True: 641k, False: 372]
  |  Branch (48:25): [True: 643k, False: 0]
  ------------------
   49|   643k|         }
   50|   643k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   643k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   643k|         else {
   46|   643k|            auto m = in.template mark< M >();
   47|   643k|            using m_t = decltype( m );
   48|  1.28M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 641k, False: 1.29k]
  |  Branch (48:25): [True: 641k, False: 0]
  ------------------
   49|   643k|         }
   50|   643k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9str_labelENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  11.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  11.3k|         else {
   46|  11.3k|            auto m = in.template mark< M >();
   47|  11.3k|            using m_t = decltype( m );
   48|  24.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.34k, False: 19]
  |  Branch (48:25): [True: 3.65k, False: 688]
  |  Branch (48:25): [True: 4.36k, False: 6.94k]
  ------------------
   49|  11.3k|         }
   50|  11.3k|      }
_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.34k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.34k|         else {
   46|  4.34k|            auto m = in.template mark< M >();
   47|  4.34k|            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: 2.51k, False: 0]
  |  Branch (48:25): [True: 2.39k, False: 124]
  |  Branch (48:25): [True: 2.51k, False: 83]
  |  Branch (48:25): [True: 2.60k, False: 0]
  |  Branch (48:25): [True: 2.60k, False: 1.74k]
  |  Branch (48:25): [True: 4.34k, False: 0]
  ------------------
   49|  4.34k|         }
   50|  4.34k|      }
_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.34k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.34k|         else {
   46|  4.34k|            auto m = in.template mark< M >();
   47|  4.34k|            using m_t = decltype( m );
   48|  6.11k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.76k, False: 2.57k]
  |  Branch (48:25): [True: 1.71k, False: 59]
  ------------------
   49|  4.34k|         }
   50|  4.34k|      }
_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.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.13k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.53k, False: 65]
  |  Branch (48:25): [True: 2.51k, False: 18]
  ------------------
   49|  2.60k|         }
   50|  2.60k|      }
_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.63k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.63k|         else {
   46|  4.63k|            auto m = in.template mark< M >();
   47|  4.63k|            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.56k, False: 2.07k]
  |  Branch (48:25): [True: 2.10k, False: 466]
  ------------------
   49|  4.63k|         }
   50|  4.63k|      }
_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|  28.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  28.7k|         else {
   46|  28.7k|            auto m = in.template mark< M >();
   47|  28.7k|            using m_t = decltype( m );
   48|  33.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.72k, False: 24.0k]
  |  Branch (48:25): [True: 3.16k, False: 1.56k]
  ------------------
   49|  28.7k|         }
   50|  28.7k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  38.1k|      {
   58|  38.1k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  38.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSI_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  38.1k|      {
   45|  76.3k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 26, False: 38.1k]
  |  Branch (45:19): [True: 38.0k, False: 103]
  ------------------
   46|  38.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  38.1k|      {
   58|  38.1k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  38.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  38.1k|      {
   45|  50.3k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 946, False: 147]
  |  Branch (45:19): [True: 44, False: 103]
  |  Branch (45:19): [True: 14, False: 1.09k]
  |  Branch (45:19): [True: 2.70k, False: 1.10k]
  |  Branch (45:19): [True: 34.3k, False: 3.81k]
  ------------------
   46|  38.1k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  40.5k|      {
   58|  40.5k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  40.5k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  40.5k|      {
   45|  78.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.00k, False: 37.5k]
  |  Branch (45:19): [True: 2.02k, False: 35.4k]
  ------------------
   46|  40.5k|      }
_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|  40.6k|      {
   58|  40.6k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  40.6k|      }
_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|  40.6k|      {
   45|   477k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 5.26k, False: 11.3k]
  |  Branch (45:19): [True: 4.00k, False: 7.30k]
  |  Branch (45:19): [True: 2.46k, False: 16.5k]
  |  Branch (45:19): [True: 3.00k, False: 19.0k]
  |  Branch (45:19): [True: 2.88k, False: 22.0k]
  |  Branch (45:19): [True: 2.76k, False: 24.9k]
  |  Branch (45:19): [True: 2.90k, False: 27.6k]
  |  Branch (45:19): [True: 3.80k, False: 30.5k]
  |  Branch (45:19): [True: 3.32k, False: 34.3k]
  |  Branch (45:19): [True: 2.98k, False: 37.7k]
  ------------------
   46|  40.6k|      }
_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.42k|      {
   58|  3.42k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.42k|      }
_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.42k|      {
   45|  4.82k|         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: 1.39k]
  |  Branch (45:19): [True: 943, False: 452]
  ------------------
   46|  3.42k|      }
_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.42k|      {
   58|  3.42k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.42k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.42k|      {
   45|  27.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 273, False: 1.97k]
  |  Branch (45:19): [True: 203, False: 1.77k]
  |  Branch (45:19): [True: 522, False: 2.24k]
  |  Branch (45:19): [True: 216, False: 2.76k]
  |  Branch (45:19): [True: 217, False: 2.98k]
  |  Branch (45:19): [True: 223, False: 3.20k]
  ------------------
   46|  3.42k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.70M|      {
   58|  1.70M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.70M|      }
_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.70M|      {
   45|  3.41M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.74k, False: 1.70M]
  |  Branch (45:19): [True: 1.70M, False: 1.61k]
  ------------------
   46|  1.70M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.65k|      {
   58|  3.65k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.65k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.65k|      {
   45|  5.00k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.31k, False: 1.34k]
  |  Branch (45:19): [True: 1.00k, False: 337]
  ------------------
   46|  3.65k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.65k|      {
   58|  3.65k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.65k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.65k|      {
   45|  29.3k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 361, False: 2.17k]
  |  Branch (45:19): [True: 204, False: 1.96k]
  |  Branch (45:19): [True: 229, False: 2.53k]
  |  Branch (45:19): [True: 271, False: 2.76k]
  |  Branch (45:19): [True: 409, False: 3.03k]
  |  Branch (45:19): [True: 212, False: 3.44k]
  ------------------
   46|  3.65k|      }
_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|  15.6M|      {
   58|  15.6M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  15.6M|      }
_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|  15.6M|      {
   45|  30.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 239k, False: 15.3M]
  |  Branch (45:19): [True: 15.3M, False: 207]
  ------------------
   46|  15.6M|      }
_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|   239k|      {
   58|   239k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   239k|      }
_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|   239k|      {
   45|   708k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 94.1k, False: 4.37k]
  |  Branch (45:19): [True: 4.30k, False: 65]
  |  Branch (45:19): [True: 34.9k, False: 98.5k]
  |  Branch (45:19): [True: 106k, False: 133k]
  ------------------
   46|   239k|      }
_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.14k|      {
   58|  4.14k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.14k|      }
_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.14k|      {
   45|  5.67k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.62k, False: 1.52k]
  |  Branch (45:19): [True: 1.17k, False: 352]
  ------------------
   46|  4.14k|      }
_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.14k|      {
   58|  4.14k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.14k|      }
_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.14k|      {
   45|  35.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 296, False: 2.89k]
  |  Branch (45:19): [True: 216, False: 2.67k]
  |  Branch (45:19): [True: 196, False: 3.18k]
  |  Branch (45:19): [True: 216, False: 3.38k]
  |  Branch (45:19): [True: 339, False: 3.59k]
  |  Branch (45:19): [True: 211, False: 3.93k]
  ------------------
   46|  4.14k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.27M|      {
   58|  9.27M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.27M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.27M|      {
   45|  18.4M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 127k, False: 9.14M]
  |  Branch (45:19): [True: 9.14M, False: 201]
  ------------------
   46|  9.27M|      }
_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|   127k|      {
   58|   127k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   127k|      }
_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|   127k|      {
   45|   387k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 42.2k, False: 696]
  |  Branch (45:19): [True: 638, False: 58]
  |  Branch (45:19): [True: 43.5k, False: 42.9k]
  |  Branch (45:19): [True: 41.0k, False: 86.5k]
  ------------------
   46|   127k|      }
_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.21k|      {
   58|  3.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.21k|      }
_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.21k|      {
   45|  4.42k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.00k, False: 1.20k]
  |  Branch (45:19): [True: 890, False: 318]
  ------------------
   46|  3.21k|      }
_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.21k|      {
   58|  3.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.21k|      }
_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.21k|      {
   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: 257, False: 2.14k]
  |  Branch (45:19): [True: 202, False: 1.94k]
  |  Branch (45:19): [True: 194, False: 2.40k]
  |  Branch (45:19): [True: 197, False: 2.59k]
  |  Branch (45:19): [True: 220, False: 2.79k]
  |  Branch (45:19): [True: 204, False: 3.01k]
  ------------------
   46|  3.21k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.83M|      {
   58|  7.83M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.83M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.83M|      {
   45|  15.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 161k, False: 7.67M]
  |  Branch (45:19): [True: 7.67M, False: 164]
  ------------------
   46|  7.83M|      }
_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|   161k|      {
   58|   161k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   161k|      }
_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|   161k|      {
   45|   459k|         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: 2.25k]
  |  Branch (45:19): [True: 2.19k, False: 55]
  |  Branch (45:19): [True: 26.0k, False: 60.9k]
  |  Branch (45:19): [True: 74.6k, False: 86.9k]
  ------------------
   46|   161k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.99k|      {
   58|  2.99k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.99k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.99k|      {
   45|  4.19k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.78k, False: 1.20k]
  |  Branch (45:19): [True: 969, False: 235]
  ------------------
   46|  2.99k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.99k|      {
   58|  2.99k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.99k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.99k|      {
   45|  25.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 332, False: 1.97k]
  |  Branch (45:19): [True: 583, False: 1.39k]
  |  Branch (45:19): [True: 66, False: 2.30k]
  |  Branch (45:19): [True: 194, False: 2.37k]
  |  Branch (45:19): [True: 207, False: 2.56k]
  |  Branch (45:19): [True: 218, False: 2.77k]
  ------------------
   46|  2.99k|      }
_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.45M|      {
   58|  2.45M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.45M|      }
_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.45M|      {
   45|  4.91M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 5.33k, False: 2.45M]
  |  Branch (45:19): [True: 2.45M, False: 162]
  ------------------
   46|  2.45M|      }
_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|  5.33k|      {
   58|  5.33k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.33k|      }
_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|  5.33k|      {
   45|  18.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.53k, False: 236]
  |  Branch (45:19): [True: 210, False: 26]
  |  Branch (45:19): [True: 1.04k, False: 2.76k]
  |  Branch (45:19): [True: 1.52k, False: 3.80k]
  ------------------
   46|  5.33k|      }
_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.21k|      {
   58|  3.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.21k|      }
_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.21k|      {
   45|  4.47k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.95k, False: 1.26k]
  |  Branch (45:19): [True: 930, False: 331]
  ------------------
   46|  3.21k|      }
_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.21k|      {
   58|  3.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.21k|      }
_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.21k|      {
   45|  27.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 270, False: 2.18k]
  |  Branch (45:19): [True: 197, False: 1.98k]
  |  Branch (45:19): [True: 194, False: 2.45k]
  |  Branch (45:19): [True: 261, False: 2.64k]
  |  Branch (45:19): [True: 223, False: 2.90k]
  |  Branch (45:19): [True: 82, False: 3.13k]
  ------------------
   46|  3.21k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.50M|      {
   58|  6.50M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.50M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.50M|      {
   45|  12.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 69.8k, False: 6.43M]
  |  Branch (45:19): [True: 6.43M, False: 205]
  ------------------
   46|  6.50M|      }
_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|  69.8k|      {
   58|  69.8k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  69.8k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  69.8k|      {
   45|   197k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 23.9k, False: 437]
  |  Branch (45:19): [True: 379, False: 58]
  |  Branch (45:19): [True: 14.9k, False: 24.4k]
  |  Branch (45:19): [True: 30.5k, False: 39.3k]
  ------------------
   46|  69.8k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.45k|      {
   58|  3.45k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.45k|      }
_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.45k|      {
   45|  4.54k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.36k, False: 1.09k]
  |  Branch (45:19): [True: 635, False: 456]
  ------------------
   46|  3.45k|      }
_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.45k|      {
   58|  3.45k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.45k|      }
_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.45k|      {
   45|  27.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 493, False: 1.87k]
  |  Branch (45:19): [True: 467, False: 1.40k]
  |  Branch (45:19): [True: 293, False: 2.36k]
  |  Branch (45:19): [True: 334, False: 2.65k]
  |  Branch (45:19): [True: 212, False: 2.99k]
  |  Branch (45:19): [True: 253, False: 3.20k]
  ------------------
   46|  3.45k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   327k|      {
   58|   327k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   327k|      }
_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|   327k|      {
   45|   486k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 169k, False: 158k]
  |  Branch (45:19): [True: 158k, False: 49]
  ------------------
   46|   327k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.74k|      {
   58|  2.74k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.74k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.74k|      {
   45|  3.59k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.90k, False: 847]
  |  Branch (45:19): [True: 562, False: 285]
  ------------------
   46|  2.74k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.74k|      {
   58|  2.74k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.74k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.74k|      {
   45|  22.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 186, False: 1.71k]
  |  Branch (45:19): [True: 212, False: 1.50k]
  |  Branch (45:19): [True: 227, False: 1.90k]
  |  Branch (45:19): [True: 194, False: 2.13k]
  |  Branch (45:19): [True: 220, False: 2.32k]
  |  Branch (45:19): [True: 204, False: 2.54k]
  ------------------
   46|  2.74k|      }
_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.80M|      {
   58|  7.80M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.80M|      }
_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.80M|      {
   45|  15.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 88.2k, False: 7.71M]
  |  Branch (45:19): [True: 7.71M, False: 169]
  ------------------
   46|  7.80M|      }
_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|  88.2k|      {
   58|  88.2k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  88.2k|      }
_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|  88.2k|      {
   45|   301k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 37.2k, False: 1.24k]
  |  Branch (45:19): [True: 1.20k, False: 39]
  |  Branch (45:19): [True: 28.9k, False: 38.5k]
  |  Branch (45:19): [True: 20.7k, False: 67.4k]
  ------------------
   46|  88.2k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  5.97k|      {
   58|  5.97k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.97k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  5.97k|      {
   45|  8.83k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.11k, False: 2.86k]
  |  Branch (45:19): [True: 2.14k, False: 714]
  ------------------
   46|  5.97k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  5.97k|      {
   58|  5.97k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.97k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  5.97k|      {
   45|  54.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 272, False: 4.85k]
  |  Branch (45:19): [True: 200, False: 4.65k]
  |  Branch (45:19): [True: 307, False: 5.12k]
  |  Branch (45:19): [True: 217, False: 5.43k]
  |  Branch (45:19): [True: 215, False: 5.64k]
  |  Branch (45:19): [True: 109, False: 5.86k]
  ------------------
   46|  5.97k|      }
_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|  45.0M|      {
   58|  45.0M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  45.0M|      }
_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|  45.0M|      {
   45|  89.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 186k, False: 44.8M]
  |  Branch (45:19): [True: 44.8M, False: 270]
  ------------------
   46|  45.0M|      }
_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|   186k|      {
   58|   186k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   186k|      }
_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|   186k|      {
   45|   709k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 112k, False: 491]
  |  Branch (45:19): [True: 430, False: 61]
  |  Branch (45:19): [True: 36.0k, False: 112k]
  |  Branch (45:19): [True: 38.0k, False: 148k]
  ------------------
   46|   186k|      }
_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.34k|      {
   58|  4.34k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.34k|      {
   45|  6.25k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.43k, False: 1.91k]
  |  Branch (45:19): [True: 1.57k, False: 341]
  ------------------
   46|  4.34k|      }
_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.34k|      {
   58|  4.34k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.34k|      {
   45|  36.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 426, False: 2.82k]
  |  Branch (45:19): [True: 246, False: 2.57k]
  |  Branch (45:19): [True: 200, False: 3.24k]
  |  Branch (45:19): [True: 402, False: 3.44k]
  |  Branch (45:19): [True: 255, False: 3.85k]
  |  Branch (45:19): [True: 240, False: 4.10k]
  ------------------
   46|  4.34k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.08M|      {
   58|  9.08M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.08M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.08M|      {
   45|  18.0M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 88.7k, False: 8.99M]
  |  Branch (45:19): [True: 8.99M, False: 198]
  ------------------
   46|  9.08M|      }
_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|  88.7k|      {
   58|  88.7k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  88.7k|      }
_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|  88.7k|      {
   45|   257k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 26.1k, False: 1.67k]
  |  Branch (45:19): [True: 1.61k, False: 58]
  |  Branch (45:19): [True: 27.9k, False: 27.8k]
  |  Branch (45:19): [True: 32.9k, False: 55.7k]
  ------------------
   46|  88.7k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|   143k|      {
   41|   160k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 17.4k, False: 143k]
  ------------------
   42|  17.4k|         }
   43|   143k|         return true;
   44|   143k|      }
_ZN3tao5pegtl8internal4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEbRT3_DpOT4_:
   40|  10.3k|      {
   41|   331k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 320k, False: 10.3k]
  ------------------
   42|   320k|         }
   43|  10.3k|         return true;
   44|  10.3k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.43k|      {
   41|  7.70k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.26k, False: 4.43k]
  ------------------
   42|  3.26k|         }
   43|  4.43k|         return true;
   44|  4.43k|      }
_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.18k|      {
   41|   851k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 849k, False: 2.18k]
  ------------------
   42|   849k|         }
   43|  2.18k|         return true;
   44|  2.18k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.91k|      {
   41|  6.99k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.07k, False: 4.91k]
  ------------------
   42|  2.07k|         }
   43|  4.91k|         return true;
   44|  4.91k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.44k|      {
   41|   315k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 312k, False: 2.44k]
  ------------------
   42|   312k|         }
   43|  2.44k|         return true;
   44|  2.44k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.51k|      {
   41|  8.58k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.06k, False: 5.51k]
  ------------------
   42|  3.06k|         }
   43|  5.51k|         return true;
   44|  5.51k|      }
_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.73k|      {
   41|  6.33k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.59k, False: 2.73k]
  ------------------
   42|  3.59k|         }
   43|  2.73k|         return true;
   44|  2.73k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.26k|      {
   41|  6.42k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.15k, False: 4.26k]
  ------------------
   42|  2.15k|         }
   43|  4.26k|         return true;
   44|  4.26k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.11k|      {
   41|  5.52k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.41k, False: 2.11k]
  ------------------
   42|  3.41k|         }
   43|  2.11k|         return true;
   44|  2.11k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.78k|      {
   41|  6.09k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.31k, False: 3.78k]
  ------------------
   42|  2.31k|         }
   43|  3.78k|         return true;
   44|  3.78k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  1.88k|      {
   41|  3.78k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.90k, False: 1.88k]
  ------------------
   42|  1.90k|         }
   43|  1.88k|         return true;
   44|  1.88k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.18k|      {
   41|  6.85k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.67k, False: 4.18k]
  ------------------
   42|  2.67k|         }
   43|  4.18k|         return true;
   44|  4.18k|      }
_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.06k|      {
   41|  4.44k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.37k, False: 2.06k]
  ------------------
   42|  2.37k|         }
   43|  2.06k|         return true;
   44|  2.06k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.15k|      {
   41|  8.40k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.25k, False: 5.15k]
  ------------------
   42|  3.25k|         }
   43|  5.15k|         return true;
   44|  5.15k|      }
_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.55k|      {
   41|   163k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 160k, False: 2.55k]
  ------------------
   42|   160k|         }
   43|  2.55k|         return true;
   44|  2.55k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.03k|      {
   41|  6.43k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.40k, False: 4.03k]
  ------------------
   42|  2.40k|         }
   43|  4.03k|         return true;
   44|  4.03k|      }
_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|  1.99k|      {
   41|  4.13k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.14k, False: 1.99k]
  ------------------
   42|  2.14k|         }
   43|  1.99k|         return true;
   44|  1.99k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.27k|      {
   41|  8.42k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.15k, False: 6.27k]
  ------------------
   42|  2.15k|         }
   43|  6.27k|         return true;
   44|  6.27k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.61k|      {
   41|   638k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 635k, False: 3.61k]
  ------------------
   42|   635k|         }
   43|  3.61k|         return true;
   44|  3.61k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   641k|      {
   41|  29.4M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 28.8M, False: 641k]
  ------------------
   42|  28.8M|         }
   43|   641k|         return true;
   44|   641k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.12k|      {
   41|  6.69k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.57k, False: 5.12k]
  ------------------
   42|  1.57k|         }
   43|  5.12k|         return true;
   44|  5.12k|      }
_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.53k|      {
   41|  4.63k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.10k, False: 2.53k]
  ------------------
   42|  2.10k|         }
   43|  2.53k|         return true;
   44|  2.53k|      }
_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|  25.6k|      {
   41|  28.7k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.16k, False: 25.6k]
  ------------------
   42|  3.16k|         }
   43|  25.6k|         return true;
   44|  25.6k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   411k|   {
   24|   411k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   411k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  38.1k|      {
   52|  38.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 38.1k, False: 43]
  ------------------
   53|  38.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 34.3k, False: 3.77k]
  ------------------
   54|  34.3k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  34.3k|               return true;
   56|  34.3k|            }
   57|  38.1k|         }
   58|  3.81k|         return false;
   59|  38.1k|      }
_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.77k, False: 43]
  ------------------
   53|  3.77k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.70k, False: 1.06k]
  ------------------
   54|  2.70k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.70k|               return true;
   56|  2.70k|            }
   57|  3.77k|         }
   58|  1.10k|         return false;
   59|  3.81k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.10k|      {
   52|  1.10k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 1.02k, False: 80]
  ------------------
   53|  1.02k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 14, False: 1.01k]
  ------------------
   54|     14|               bump_help< string >( in, sizeof...( Cs ) );
   55|     14|               return true;
   56|     14|            }
   57|  1.02k|         }
   58|  1.09k|         return false;
   59|  1.10k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.09k|      {
   52|  1.09k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 1.05k, False: 43]
  ------------------
   53|  1.05k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 946, False: 104]
  ------------------
   54|    946|               bump_help< string >( in, sizeof...( Cs ) );
   55|    946|               return true;
   56|    946|            }
   57|  1.05k|         }
   58|    147|         return false;
   59|  1.09k|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    147|      {
   52|    147|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 68, False: 79]
  ------------------
   53|     68|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 44, False: 24]
  ------------------
   54|     44|               bump_help< string >( in, sizeof...( Cs ) );
   55|     44|               return true;
   56|     44|            }
   57|     68|         }
   58|    103|         return false;
   59|    147|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  40.6k|      {
   52|  40.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 38.9k, False: 1.72k]
  ------------------
   53|  38.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.45k, False: 35.5k]
  ------------------
   54|  3.45k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.45k|               return true;
   56|  3.45k|            }
   57|  38.9k|         }
   58|  37.2k|         return false;
   59|  40.6k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  37.1k|      {
   52|  37.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 30.4k, False: 6.72k]
  ------------------
   53|  30.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 1.95k, False: 28.4k]
  ------------------
   54|  1.95k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  1.95k|               return true;
   56|  1.95k|            }
   57|  30.4k|         }
   58|  35.2k|         return false;
   59|  37.1k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  35.2k|      {
   52|  35.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.4k, False: 6.72k]
  ------------------
   53|  28.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.51k, False: 25.9k]
  ------------------
   54|  2.51k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.51k|               return true;
   56|  2.51k|            }
   57|  28.4k|         }
   58|  32.6k|         return false;
   59|  35.2k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  32.6k|      {
   52|  32.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 24.6k, False: 8.01k]
  ------------------
   53|  24.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.50k, False: 22.1k]
  ------------------
   54|  2.50k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.50k|               return true;
   56|  2.50k|            }
   57|  24.6k|         }
   58|  30.1k|         return false;
   59|  32.6k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.1k|      {
   52|  30.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.4k, False: 13.7k]
  ------------------
   53|  16.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.42k, False: 14.0k]
  ------------------
   54|  2.42k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.42k|               return true;
   56|  2.42k|            }
   57|  16.4k|         }
   58|  27.7k|         return false;
   59|  30.1k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  27.7k|      {
   52|  27.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 21.0k, False: 6.72k]
  ------------------
   53|  21.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.16k, False: 17.8k]
  ------------------
   54|  3.16k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.16k|               return true;
   56|  3.16k|            }
   57|  21.0k|         }
   58|  24.6k|         return false;
   59|  27.7k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_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: 15.0k, False: 9.50k]
  ------------------
   53|  15.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.73k, False: 12.3k]
  ------------------
   54|  2.73k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.73k|               return true;
   56|  2.73k|            }
   57|  15.0k|         }
   58|  21.8k|         return false;
   59|  24.6k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_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: 35.6k, False: 2.00k]
  ------------------
   53|  35.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.67k, False: 32.0k]
  ------------------
   54|  3.67k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.67k|               return true;
   56|  3.67k|            }
   57|  35.6k|         }
   58|  34.0k|         return false;
   59|  37.7k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  34.3k|      {
   52|  34.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 32.3k, False: 2.00k]
  ------------------
   53|  32.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.17k, False: 28.2k]
  ------------------
   54|  4.17k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.17k|               return true;
   56|  4.17k|            }
   57|  32.3k|         }
   58|  30.2k|         return false;
   59|  34.3k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.5k|      {
   52|  30.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 25.1k, False: 5.44k]
  ------------------
   53|  25.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.23k, False: 21.9k]
  ------------------
   54|  3.23k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.23k|               return true;
   56|  3.23k|            }
   57|  25.1k|         }
   58|  27.3k|         return false;
   59|  30.5k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  27.6k|      {
   52|  27.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 25.2k, False: 2.40k]
  ------------------
   53|  25.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.01k, False: 22.2k]
  ------------------
   54|  3.01k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.01k|               return true;
   56|  3.01k|            }
   57|  25.2k|         }
   58|  24.6k|         return false;
   59|  27.6k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  24.9k|      {
   52|  24.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 21.5k, False: 3.35k]
  ------------------
   53|  21.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.23k, False: 18.3k]
  ------------------
   54|  3.23k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.23k|               return true;
   56|  3.23k|            }
   57|  21.5k|         }
   58|  21.6k|         return false;
   59|  24.9k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  22.0k|      {
   52|  22.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.2k, False: 5.75k]
  ------------------
   53|  16.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.46k, False: 12.8k]
  ------------------
   54|  3.46k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.46k|               return true;
   56|  3.46k|            }
   57|  16.2k|         }
   58|  18.5k|         return false;
   59|  22.0k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  19.0k|      {
   52|  19.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 12.4k, False: 6.58k]
  ------------------
   53|  12.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.76k, False: 9.69k]
  ------------------
   54|  2.76k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.76k|               return true;
   56|  2.76k|            }
   57|  12.4k|         }
   58|  16.2k|         return false;
   59|  19.0k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  16.5k|      {
   52|  16.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 14.8k, False: 1.72k]
  ------------------
   53|  14.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 6.00k, False: 8.84k]
  ------------------
   54|  6.00k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  6.00k|               return true;
   56|  6.00k|            }
   57|  14.8k|         }
   58|  10.5k|         return false;
   59|  16.5k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  11.3k|      {
   52|  11.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 9.16k, False: 2.14k]
  ------------------
   53|  9.16k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.36k, False: 4.79k]
  ------------------
   54|  4.36k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.36k|               return true;
   56|  4.36k|            }
   57|  9.16k|         }
   58|  6.94k|         return false;
   59|  11.3k|      }

_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   316k|      {
   71|   316k|         auto m = in.template mark< M >();
   72|   316k|         using m_t = decltype( m );
   73|       |
   74|  15.9M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 15.6M, False: 315k]
  ------------------
   75|  15.6M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 207, False: 15.6M]
  ------------------
   76|    207|               return false;
   77|    207|            }
   78|  15.6M|         }
   79|   315k|         return m( true );
   80|   316k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  7.54k|      {
   71|  7.54k|         auto m = in.template mark< M >();
   72|  7.54k|         using m_t = decltype( m );
   73|       |
   74|  9.28M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.27M, False: 7.34k]
  ------------------
   75|  9.27M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 201, False: 9.27M]
  ------------------
   76|    201|               return false;
   77|    201|            }
   78|  9.27M|         }
   79|  7.34k|         return m( true );
   80|  7.54k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.45k|      {
   71|  6.45k|         auto m = in.template mark< M >();
   72|  6.45k|         using m_t = decltype( m );
   73|       |
   74|  7.83M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.83M, False: 6.28k]
  ------------------
   75|  7.83M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 164, False: 7.83M]
  ------------------
   76|    164|               return false;
   77|    164|            }
   78|  7.83M|         }
   79|  6.28k|         return m( true );
   80|  6.45k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.77k|      {
   71|  4.77k|         auto m = in.template mark< M >();
   72|  4.77k|         using m_t = decltype( m );
   73|       |
   74|  2.46M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 2.45M, False: 4.61k]
  ------------------
   75|  2.45M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 162, False: 2.45M]
  ------------------
   76|    162|               return false;
   77|    162|            }
   78|  2.45M|         }
   79|  4.61k|         return m( true );
   80|  4.77k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.39k|      {
   71|  5.39k|         auto m = in.template mark< M >();
   72|  5.39k|         using m_t = decltype( m );
   73|       |
   74|  6.50M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.50M, False: 5.19k]
  ------------------
   75|  6.50M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 205, False: 6.50M]
  ------------------
   76|    205|               return false;
   77|    205|            }
   78|  6.50M|         }
   79|  5.19k|         return m( true );
   80|  5.39k|      }
_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|  4.73k|      {
   71|  4.73k|         auto m = in.template mark< M >();
   72|  4.73k|         using m_t = decltype( m );
   73|       |
   74|  7.81M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.80M, False: 4.56k]
  ------------------
   75|  7.80M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 169, False: 7.80M]
  ------------------
   76|    169|               return false;
   77|    169|            }
   78|  7.80M|         }
   79|  4.56k|         return m( true );
   80|  4.73k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  36.1k|      {
   71|  36.1k|         auto m = in.template mark< M >();
   72|  36.1k|         using m_t = decltype( m );
   73|       |
   74|  45.0M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 45.0M, False: 35.8k]
  ------------------
   75|  45.0M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 270, False: 45.0M]
  ------------------
   76|    270|               return false;
   77|    270|            }
   78|  45.0M|         }
   79|  35.8k|         return m( true );
   80|  36.1k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.24k|      {
   71|  6.24k|         auto m = in.template mark< M >();
   72|  6.24k|         using m_t = decltype( m );
   73|       |
   74|  9.08M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.08M, False: 6.05k]
  ------------------
   75|  9.08M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 198, False: 9.08M]
  ------------------
   76|    198|               return false;
   77|    198|            }
   78|  9.08M|         }
   79|  6.05k|         return m( true );
   80|  6.24k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.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: 29.0k, False: 9.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|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 9.13k]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|  9.13k|         else {
  160|  9.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.13k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_controlIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.1k|      {
   44|  38.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.1k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 143k, False: 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|   143k|            else if constexpr( has_apply0_bool ) {
  153|   143k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   143k|            }
  155|   143k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 143k, False: 0]
  ------------------
  157|   143k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   143k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_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|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   143k|      {
   44|   143k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   143k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   244k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   244k|      else {
  108|   244k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   244k|         using iterator_t = typename ParseInput::iterator_t;
  111|   244k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   244k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   244k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   244k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   244k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   244k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   244k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   244k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   244k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   244k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   244k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   244k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   244k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   244k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   244k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   244k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   244k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   244k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 22.7k, False: 221k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  22.7k|            else if constexpr( has_apply0_bool ) {
  153|  22.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.7k|            }
  155|  22.7k|         }
  156|   244k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.7k, False: 221k]
  ------------------
  157|  22.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.7k|         }
  159|   221k|         else {
  160|   221k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   221k|         }
  162|   244k|         (void)m( result );
  163|   244k|         return result;
  164|   244k|      }
  165|   244k|   }
_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|   244k|      {
   73|   244k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   244k|         else {
   84|   244k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   244k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   244k|      }
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|   244k|      {
   59|   244k|         return Rule::match( in );
   60|   244k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  38.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: 33.5k, False: 4.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|  33.5k|            else if constexpr( has_apply0_bool ) {
  153|  33.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.5k|            }
  155|  33.5k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.5k, False: 4.60k]
  ------------------
  157|  33.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.5k|         }
  159|  4.60k|         else {
  160|  4.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.60k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS6_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS6_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.1k|      {
   44|  38.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.1k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  38.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: 33.4k, False: 4.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|  33.4k|            else if constexpr( has_apply0_bool ) {
  153|  33.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.4k|            }
  155|  33.4k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.4k, False: 4.70k]
  ------------------
  157|  33.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.4k|         }
  159|  4.70k|         else {
  160|  4.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.70k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.1k|      {
   44|  38.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  71.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  71.6k|      else {
  108|  71.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  71.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  71.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|  71.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|  71.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|  71.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): [True: 0, Folded]
  ------------------
  116|  71.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|  71.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [True: 71.6k, Folded]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  71.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  71.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  71.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  71.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|  71.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  71.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  71.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|  71.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  71.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  71.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  71.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  71.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.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|  10.3k|            else if constexpr( has_apply0_void ) {
  150|  10.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  10.3k|         }
  156|  71.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.2k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.2k|         else {
  160|  61.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.2k|         }
  162|  71.6k|         (void)m( result );
  163|  71.6k|         return result;
  164|  71.6k|      }
  165|  71.6k|   }
_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|  71.6k|      {
   73|  71.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|  71.6k|         else {
   84|  71.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  71.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  71.6k|      }
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|  71.6k|      {
   44|  71.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  71.6k|      }
_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|  71.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  71.6k|      else {
  108|  71.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  71.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  71.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|  71.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|  71.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|  71.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|  71.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|  71.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|  71.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  71.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  71.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  71.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|  71.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  71.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  71.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|  71.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  71.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  71.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  71.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  71.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.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|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  71.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.2k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.2k|         else {
  160|  61.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.2k|         }
  162|  71.6k|         (void)m( result );
  163|  71.6k|         return result;
  164|  71.6k|      }
  165|  71.6k|   }
_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|  71.6k|      {
   73|  71.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|  71.6k|         else {
   84|  71.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  71.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  71.6k|      }
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|  71.6k|      {
   44|  71.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  71.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  71.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  71.6k|      else {
  108|  71.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  71.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  71.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|  71.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|  71.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|  71.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|  71.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|  71.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|  71.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  71.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  71.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  71.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|  71.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  71.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  71.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|  71.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  71.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  71.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  71.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  71.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.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|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  71.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.2k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.2k|         else {
  160|  61.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.2k|         }
  162|  71.6k|         (void)m( result );
  163|  71.6k|         return result;
  164|  71.6k|      }
  165|  71.6k|   }
_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|  71.6k|      {
   73|  71.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|  71.6k|         else {
   84|  71.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  71.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  71.6k|      }
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|  71.6k|      {
   59|  71.6k|         return Rule::match( in );
   60|  71.6k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|  10.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  10.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  10.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.3k|      {
   44|  10.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.3k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.3k|      else {
  108|  10.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  10.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 0]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  10.3k|         (void)m( result );
  163|  10.3k|         return result;
  164|  10.3k|      }
  165|  10.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDaRT4_DpOT5_:
   72|  10.3k|      {
   73|  10.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.3k|         else {
   84|  10.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.3k|      {
   44|  10.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.3k|      }
_ZN3tao5pegtl5matchINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 320k, 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|   320k|            else if constexpr( has_apply0_bool ) {
  153|   320k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   320k|            }
  155|   320k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 320k, False: 10.3k]
  ------------------
  157|   320k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   320k|         }
  159|  10.3k|         else {
  160|  10.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.3k|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_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|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   331k|      {
   44|   331k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   331k|      }
_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|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 320k, 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|   320k|            else if constexpr( has_apply0_bool ) {
  153|   320k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   320k|            }
  155|   320k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 320k, False: 10.3k]
  ------------------
  157|   320k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   320k|         }
  159|  10.3k|         else {
  160|  10.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.3k|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_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|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   331k|      {
   44|   331k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   331k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded, False: 331k]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded, False: 331k]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded, False: 331k]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded, False: 331k]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 320k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 320k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|   320k|         else {
  160|   320k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   320k|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_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|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   331k|      {
   59|   331k|         return Rule::match( in );
   60|   331k|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   320k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   320k|      else {
  108|   320k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   320k|         using iterator_t = typename ParseInput::iterator_t;
  111|   320k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   320k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   320k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   320k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   320k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   320k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   320k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   320k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   320k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   320k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   320k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   320k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   320k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   320k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   320k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   320k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   320k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   320k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 320k, 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|   320k|            else if constexpr( has_apply0_bool ) {
  153|   320k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   320k|            }
  155|   320k|         }
  156|   320k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 320k, False: 0]
  ------------------
  157|   320k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   320k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   320k|         (void)m( result );
  163|   320k|         return result;
  164|   320k|      }
  165|   320k|   }
_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|   320k|      {
   73|   320k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   320k|         else {
   84|   320k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   320k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   320k|      }
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|   320k|      {
   59|   320k|         return Rule::match( in );
   60|   320k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 33.4k, False: 4.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|  33.4k|            else if constexpr( has_apply0_bool ) {
  153|  33.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.4k|            }
  155|  33.4k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.4k, False: 4.70k]
  ------------------
  157|  33.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.4k|         }
  159|  4.70k|         else {
  160|  4.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.70k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_controlIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.1k|      {
   44|  38.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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): [True: 0, Folded]
  ------------------
  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): [True: 38.1k, Folded]
  |  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): [True: 38.1k, Folded]
  |  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: 103]
  ------------------
  143|  38.0k|            if constexpr( has_apply_void ) {
  144|  38.0k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  38.0k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.0k, False: 103]
  ------------------
  157|  38.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.0k|         }
  159|    103|         else {
  160|    103|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    103|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_controlIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.1k|      {
   44|  38.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.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: 34.3k, 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|  34.3k|            else if constexpr( has_apply0_bool ) {
  153|  34.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.3k|            }
  155|  34.3k|         }
  156|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.3k, False: 3.81k]
  ------------------
  157|  34.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.3k|         }
  159|  3.81k|         else {
  160|  3.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.81k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.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_controlIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  38.1k|      {
   59|  38.1k|         return Rule::match( in );
   60|  38.1k|      }
_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.70k, False: 1.10k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.70k|            else if constexpr( has_apply0_bool ) {
  153|  2.70k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.70k|            }
  155|  2.70k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.70k, False: 1.10k]
  ------------------
  157|  2.70k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.70k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  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.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.10k|      else {
  108|  1.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14, 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|     14|            else if constexpr( has_apply0_bool ) {
  153|     14|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     14|            }
  155|     14|         }
  156|  1.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14, False: 1.09k]
  ------------------
  157|     14|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     14|         }
  159|  1.09k|         else {
  160|  1.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.09k|         }
  162|  1.10k|         (void)m( result );
  163|  1.10k|         return result;
  164|  1.10k|      }
  165|  1.10k|   }
_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.10k|      {
   73|  1.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.10k|         else {
   84|  1.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.10k|      }
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.10k|      {
   59|  1.10k|         return Rule::match( in );
   60|  1.10k|      }
_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.09k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.09k|      else {
  108|  1.09k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.09k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.09k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.09k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.09k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.09k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.09k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.09k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.09k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.09k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.09k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.09k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.09k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.09k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.09k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.09k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.09k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.09k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.09k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.09k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 946, False: 147]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    946|            else if constexpr( has_apply0_bool ) {
  153|    946|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    946|            }
  155|    946|         }
  156|  1.09k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 946, False: 147]
  ------------------
  157|    946|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    946|         }
  159|    147|         else {
  160|    147|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    147|         }
  162|  1.09k|         (void)m( result );
  163|  1.09k|         return result;
  164|  1.09k|      }
  165|  1.09k|   }
_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.09k|      {
   73|  1.09k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.09k|         else {
   84|  1.09k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.09k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.09k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.09k|      {
   59|  1.09k|         return Rule::match( in );
   60|  1.09k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    147|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    147|      else {
  108|    147|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    147|         using iterator_t = typename ParseInput::iterator_t;
  111|    147|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    147|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    147|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    147|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    147|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    147|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    147|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    147|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    147|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    147|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    147|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    147|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    147|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    147|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    147|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    147|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    147|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    147|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44, False: 103]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     44|            else if constexpr( has_apply0_bool ) {
  153|     44|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     44|            }
  155|     44|         }
  156|    147|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44, False: 103]
  ------------------
  157|     44|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     44|         }
  159|    103|         else {
  160|    103|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    103|         }
  162|    147|         (void)m( result );
  163|    147|         return result;
  164|    147|      }
  165|    147|   }
_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|    147|      {
   73|    147|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    147|         else {
   84|    147|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    147|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    147|      }
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|    147|      {
   59|    147|         return Rule::match( in );
   60|    147|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.0k|      else {
  108|  38.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.0k, 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|  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.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.0k, False: 4]
  ------------------
  157|  38.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.0k|         }
  159|      4|         else {
  160|      4|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      4|         }
  162|  38.0k|         (void)m( result );
  163|  38.0k|         return result;
  164|  38.0k|      }
  165|  38.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  38.0k|      {
   73|  38.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|  38.0k|         else {
   84|  38.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|  38.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.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|  38.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 78.7k, False: 26.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|  78.7k|            else if constexpr( has_apply0_bool ) {
  153|  78.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  78.7k|            }
  155|  78.7k|         }
  156|   104k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 78.7k, False: 26.1k]
  ------------------
  157|  78.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  78.7k|         }
  159|  26.1k|         else {
  160|  26.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  26.1k|         }
  162|   104k|         (void)m( result );
  163|   104k|         return result;
  164|   104k|      }
  165|   104k|   }
_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|   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_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|   104k|      {
   44|   104k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   104k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_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: 78.7k, False: 26.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|  78.7k|            else if constexpr( has_apply0_bool ) {
  153|  78.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  78.7k|            }
  155|  78.7k|         }
  156|   104k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 78.7k, False: 26.1k]
  ------------------
  157|  78.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  78.7k|         }
  159|  26.1k|         else {
  160|  26.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  26.1k|         }
  162|   104k|         (void)m( result );
  163|   104k|         return result;
  164|   104k|      }
  165|   104k|   }
_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|   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_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.0k|      else {
  108|  38.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 38.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.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|  38.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|  38.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|  38.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 38.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.50k, False: 35.5k]
  ------------------
  143|  2.50k|            if constexpr( has_apply_void ) {
  144|  2.50k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.50k|         }
  156|  38.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 35.5k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  35.5k|         else {
  160|  35.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.5k|         }
  162|  38.0k|         (void)m( result );
  163|  38.0k|         return result;
  164|  38.0k|      }
  165|  38.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.0k|      {
   73|  38.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|  38.0k|         else {
   84|  38.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.0k|      else {
  108|  38.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 35.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.53k|            else if constexpr( has_apply0_bool ) {
  153|  2.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.53k|            }
  155|  2.53k|         }
  156|  38.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 35.4k]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|  35.4k|         else {
  160|  35.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.4k|         }
  162|  38.0k|         (void)m( result );
  163|  38.0k|         return result;
  164|  38.0k|      }
  165|  38.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.0k|      {
   73|  38.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|  38.0k|         else {
   84|  38.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.5k|      else {
  108|  40.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  40.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  40.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|  40.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|  40.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|  40.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|  40.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  40.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.00k, False: 37.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.00k|            else if constexpr( has_apply0_bool ) {
  153|  3.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.00k|            }
  155|  3.00k|         }
  156|  40.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.00k, False: 37.5k]
  ------------------
  157|  3.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.00k|         }
  159|  37.5k|         else {
  160|  37.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.5k|         }
  162|  40.5k|         (void)m( result );
  163|  40.5k|         return result;
  164|  40.5k|      }
  165|  40.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  40.5k|      {
   73|  40.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|  40.5k|         else {
   84|  40.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  40.5k|      {
   44|  40.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  49.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  49.6k|      else {
  108|  49.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  49.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  49.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|  49.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|  49.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|  49.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|  49.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|  49.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|  49.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  49.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  49.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  49.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|  49.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  49.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  49.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|  49.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  49.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  49.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  49.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  49.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.1k, False: 37.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|  12.1k|            else if constexpr( has_apply0_bool ) {
  153|  12.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.1k|            }
  155|  12.1k|         }
  156|  49.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.1k, False: 37.5k]
  ------------------
  157|  12.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.1k|         }
  159|  37.5k|         else {
  160|  37.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.5k|         }
  162|  49.6k|         (void)m( result );
  163|  49.6k|         return result;
  164|  49.6k|      }
  165|  49.6k|   }
_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|  49.6k|      {
   73|  49.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|  49.6k|         else {
   84|  49.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  49.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  49.6k|      }
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|  49.6k|      {
   59|  49.6k|         return Rule::match( in );
   60|  49.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  37.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.5k|      else {
  108|  37.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.02k, False: 35.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.02k|            else if constexpr( has_apply0_bool ) {
  153|  2.02k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.02k|            }
  155|  2.02k|         }
  156|  37.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.02k, False: 35.4k]
  ------------------
  157|  2.02k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.02k|         }
  159|  35.4k|         else {
  160|  35.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.4k|         }
  162|  37.5k|         (void)m( result );
  163|  37.5k|         return result;
  164|  37.5k|      }
  165|  37.5k|   }
_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|  37.5k|      {
   73|  37.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|  37.5k|         else {
   84|  37.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.5k|      }
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|  37.5k|      {
   59|  37.5k|         return Rule::match( in );
   60|  37.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 2.51k, False: 23]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.51k|            else if constexpr( has_apply0_bool ) {
  153|  2.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.51k|            }
  155|  2.51k|         }
  156|  2.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.51k, False: 23]
  ------------------
  157|  2.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.51k|         }
  159|     23|         else {
  160|     23|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     23|         }
  162|  2.53k|         (void)m( result );
  163|  2.53k|         return result;
  164|  2.53k|      }
  165|  2.53k|   }
_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|  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_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|  2.53k|      {
   59|  2.53k|         return Rule::match( in );
   60|  2.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.51k|      else {
  108|  2.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.51k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.51k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.51k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.50k, False: 10]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.50k|            else if constexpr( has_apply0_bool ) {
  153|  2.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.50k|            }
  155|  2.50k|         }
  156|  2.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.50k, False: 10]
  ------------------
  157|  2.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.50k|         }
  159|     10|         else {
  160|     10|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     10|         }
  162|  2.51k|         (void)m( result );
  163|  2.51k|         return result;
  164|  2.51k|      }
  165|  2.51k|   }
_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|  2.51k|      {
   73|  2.51k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.51k|         else {
   84|  2.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  2.51k|      {
   44|  2.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.51k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.0k|      else {
  108|  38.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.4k, False: 4.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|  33.4k|            else if constexpr( has_apply0_bool ) {
  153|  33.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.4k|            }
  155|  33.4k|         }
  156|  38.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.4k, False: 4.60k]
  ------------------
  157|  33.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.4k|         }
  159|  4.60k|         else {
  160|  4.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.60k|         }
  162|  38.0k|         (void)m( result );
  163|  38.0k|         return result;
  164|  38.0k|      }
  165|  38.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  38.0k|      {
   73|  38.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|  38.0k|         else {
   84|  38.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|  38.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.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|  38.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_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|  35.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.9k|      else {
  108|  35.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.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|  35.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|  35.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|  35.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|  35.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|  35.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|  35.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.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|  35.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.3k, False: 10.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|  25.3k|            else if constexpr( has_apply0_bool ) {
  153|  25.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.3k|            }
  155|  25.3k|         }
  156|  35.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.3k, False: 10.6k]
  ------------------
  157|  25.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.3k|         }
  159|  10.6k|         else {
  160|  10.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.6k|         }
  162|  35.9k|         (void)m( result );
  163|  35.9k|         return result;
  164|  35.9k|      }
  165|  35.9k|   }
_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|  35.9k|      {
   73|  35.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|  35.9k|         else {
   84|  35.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.9k|      }
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|  35.9k|      {
   44|  35.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.6k|      else {
  108|  40.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.7k, False: 11.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|  28.7k|            else if constexpr( has_apply0_bool ) {
  153|  28.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.7k|            }
  155|  28.7k|         }
  156|  40.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.7k, False: 11.9k]
  ------------------
  157|  28.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.7k|         }
  159|  11.9k|         else {
  160|  11.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.9k|         }
  162|  40.6k|         (void)m( result );
  163|  40.6k|         return result;
  164|  40.6k|      }
  165|  40.6k|   }
_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|  40.6k|      {
   73|  40.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|  40.6k|         else {
   84|  40.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.6k|      }
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|  40.6k|      {
   44|  40.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.6k|      else {
  108|  40.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 37.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  40.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 37.7k]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|  37.7k|         else {
  160|  37.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.7k|         }
  162|  40.6k|         (void)m( result );
  163|  40.6k|         return result;
  164|  40.6k|      }
  165|  40.6k|   }
_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|  40.6k|      {
   73|  40.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|  40.6k|         else {
   84|  40.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.6k|      }
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|  40.6k|      {
   44|  40.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.6k|      }
_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|  40.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.6k|      else {
  108|  40.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 37.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  40.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 37.7k]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|  37.7k|         else {
  160|  37.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.7k|         }
  162|  40.6k|         (void)m( result );
  163|  40.6k|         return result;
  164|  40.6k|      }
  165|  40.6k|   }
_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|  40.6k|      {
   73|  40.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|  40.6k|         else {
   84|  40.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.6k|      }
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|  40.6k|      {
   44|  40.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.6k|      else {
  108|  40.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 40.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  40.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|  40.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|  40.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|  40.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 40.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, False: 37.2k]
  ------------------
  143|  3.45k|            if constexpr( has_apply_void ) {
  144|  3.45k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.45k|         }
  156|  40.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.44k, False: 37.2k]
  ------------------
  157|  3.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.44k|         }
  159|  37.2k|         else {
  160|  37.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.2k|         }
  162|  40.6k|         (void)m( result );
  163|  40.6k|         return result;
  164|  40.6k|      }
  165|  40.6k|   }
_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|  40.6k|      {
   73|  40.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|  40.6k|         else {
   84|  40.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.6k|      }
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|  40.6k|      {
   59|  40.6k|         return Rule::match( in );
   60|  40.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   856k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   856k|      else {
  108|   856k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   856k|         using iterator_t = typename ParseInput::iterator_t;
  111|   856k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   856k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   856k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   856k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   856k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   856k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   856k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   856k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   856k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   856k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   856k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   856k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   856k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   856k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   856k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   856k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   856k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   856k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 855k, 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|   855k|            else if constexpr( has_apply0_bool ) {
  153|   855k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   855k|            }
  155|   855k|         }
  156|   856k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 855k, False: 1.10k]
  ------------------
  157|   855k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   855k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|   856k|         (void)m( result );
  163|   856k|         return result;
  164|   856k|      }
  165|   856k|   }
_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|   856k|      {
   73|   856k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   856k|         else {
   84|   856k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   856k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   856k|      }
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|   856k|      {
   44|   856k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   856k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   856k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   856k|      else {
  108|   856k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   856k|         using iterator_t = typename ParseInput::iterator_t;
  111|   856k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   856k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   856k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   856k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   856k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   856k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   856k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   856k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   856k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   856k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   856k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   856k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   856k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   856k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   856k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   856k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   856k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   856k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 855k, 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|   855k|            else if constexpr( has_apply0_bool ) {
  153|   855k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   855k|            }
  155|   855k|         }
  156|   856k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 855k, False: 1.10k]
  ------------------
  157|   855k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   855k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|   856k|         (void)m( result );
  163|   856k|         return result;
  164|   856k|      }
  165|   856k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   856k|      {
   73|   856k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   856k|         else {
   84|   856k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   856k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   856k|      }
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|   856k|      {
   59|   856k|         return Rule::match( in );
   60|   856k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   869k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   869k|      else {
  108|   869k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   869k|         using iterator_t = typename ParseInput::iterator_t;
  111|   869k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   869k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   869k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   869k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   869k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   869k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   869k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   869k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   869k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   869k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   869k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   869k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   869k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   869k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   869k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   869k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   869k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   869k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.22k, False: 860k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.22k|            else if constexpr( has_apply0_bool ) {
  153|  9.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.22k|            }
  155|  9.22k|         }
  156|   869k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.22k, False: 860k]
  ------------------
  157|  9.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.22k|         }
  159|   860k|         else {
  160|   860k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   860k|         }
  162|   869k|         (void)m( result );
  163|   869k|         return result;
  164|   869k|      }
  165|   869k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   869k|      {
   73|   869k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   869k|         else {
   84|   869k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   869k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   869k|      }
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|   869k|      {
   59|   869k|         return Rule::match( in );
   60|   869k|      }
_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.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 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.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 459]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|    459|         else {
  160|    459|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    459|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_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.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_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.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.02k, False: 1.39k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.02k|            else if constexpr( has_apply0_bool ) {
  153|  2.02k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.02k|            }
  155|  2.02k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.02k, False: 1.39k]
  ------------------
  157|  2.02k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.02k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_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.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 0]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_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.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.42k|   {
  104|  3.42k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.42k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.42k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_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.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.42k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.42k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.65k, False: 1.77k]
  ------------------
  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.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.65k, False: 1.77k]
  ------------------
  157|  1.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.65k|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_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.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 223, False: 3.20k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    223|            else if constexpr( has_apply0_bool ) {
  153|    223|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    223|            }
  155|    223|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 223, False: 3.20k]
  ------------------
  157|    223|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    223|         }
  159|  3.20k|         else {
  160|  3.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.20k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_ZN3tao5pegtl8internal20match_control_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.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_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.20k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.20k|      else {
  108|  3.20k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.20k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.20k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.20k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.20k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.20k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.20k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.20k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.20k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.20k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.20k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.20k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.20k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.20k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.20k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.20k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.20k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.20k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.20k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.20k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 217, False: 2.98k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  3.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 217, False: 2.98k]
  ------------------
  157|    217|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    217|         }
  159|  2.98k|         else {
  160|  2.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.98k|         }
  162|  3.20k|         (void)m( result );
  163|  3.20k|         return result;
  164|  3.20k|      }
  165|  3.20k|   }
_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.20k|      {
   73|  3.20k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.20k|         else {
   84|  3.20k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.20k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.20k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.20k|      {
   59|  3.20k|         return Rule::match( in );
   60|  3.20k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.98k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.98k|      else {
  108|  2.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 216, 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|    216|            else if constexpr( has_apply0_bool ) {
  153|    216|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    216|            }
  155|    216|         }
  156|  2.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 216, False: 2.76k]
  ------------------
  157|    216|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    216|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  2.98k|         (void)m( result );
  163|  2.98k|         return result;
  164|  2.98k|      }
  165|  2.98k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.98k|      {
   73|  2.98k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.98k|         else {
   84|  2.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.98k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.98k|      {
   59|  2.98k|         return Rule::match( in );
   60|  2.98k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.76k|      else {
  108|  2.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 522, False: 2.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|    522|            else if constexpr( has_apply0_bool ) {
  153|    522|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    522|            }
  155|    522|         }
  156|  2.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 522, False: 2.24k]
  ------------------
  157|    522|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    522|         }
  159|  2.24k|         else {
  160|  2.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.24k|         }
  162|  2.76k|         (void)m( result );
  163|  2.76k|         return result;
  164|  2.76k|      }
  165|  2.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.76k|      {
   73|  2.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.76k|         else {
   84|  2.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.76k|      {
   59|  2.76k|         return Rule::match( in );
   60|  2.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.24k|      else {
  108|  2.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.24k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.24k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.24k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.24k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 273, 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|    273|            else if constexpr( has_apply0_bool ) {
  153|    273|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    273|            }
  155|    273|         }
  156|  2.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 273, False: 1.97k]
  ------------------
  157|    273|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    273|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  2.24k|         (void)m( result );
  163|  2.24k|         return result;
  164|  2.24k|      }
  165|  2.24k|   }
_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.24k|      {
   73|  2.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|  2.24k|         else {
   84|  2.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.24k|      {
   59|  2.24k|         return Rule::match( in );
   60|  2.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.97k|      else {
  108|  1.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 203, False: 1.77k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    203|            else if constexpr( has_apply0_bool ) {
  153|    203|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    203|            }
  155|    203|         }
  156|  1.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 203, False: 1.77k]
  ------------------
  157|    203|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    203|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  1.97k|         (void)m( result );
  163|  1.97k|         return result;
  164|  1.97k|      }
  165|  1.97k|   }
_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|  1.97k|      {
   73|  1.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|  1.97k|         else {
   84|  1.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.97k|      }
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|  1.97k|      {
   59|  1.97k|         return Rule::match( in );
   60|  1.97k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.25k, False: 1.16k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.25k|            else if constexpr( has_apply0_bool ) {
  153|  2.25k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.25k|            }
  155|  2.25k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.25k, False: 1.16k]
  ------------------
  157|  2.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.25k|         }
  159|  1.16k|         else {
  160|  1.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.16k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.43k|      else {
  108|  4.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.43k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.43k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.43k|            else if constexpr( has_apply0_bool ) {
  153|  4.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.43k|            }
  155|  4.43k|         }
  156|  4.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.43k, False: 0]
  ------------------
  157|  4.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.43k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.43k|         (void)m( result );
  163|  4.43k|         return result;
  164|  4.43k|      }
  165|  4.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.43k|      {
   73|  4.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.43k|         else {
   84|  4.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_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.43k|      {
   44|  4.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.43k|      }
_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.25k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.25k|      else {
  108|  2.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.18k, False: 75]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.18k|            else if constexpr( has_apply0_bool ) {
  153|  2.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.18k|            }
  155|  2.18k|         }
  156|  2.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.18k, False: 75]
  ------------------
  157|  2.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.18k|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|  2.25k|         (void)m( result );
  163|  2.25k|         return result;
  164|  2.25k|      }
  165|  2.25k|   }
_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.25k|      {
   73|  2.25k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.25k|         else {
   84|  2.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.25k|      {
   44|  2.25k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.25k|      }
_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.18k|   {
  104|  2.18k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.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|  2.18k|   }
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.18k|      {
   44|  2.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.18k|      }
_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|   851k|   {
  104|   851k|      if constexpr( !Control< Rule >::enable ) {
  105|   851k|         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|   851k|   }
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|   851k|      {
   44|   851k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   851k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.18k|      else {
  108|  2.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.18k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.18k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.02k, False: 155]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.02k|            else if constexpr( has_apply0_bool ) {
  153|  2.02k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.02k|            }
  155|  2.02k|         }
  156|  2.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.02k, False: 155]
  ------------------
  157|  2.02k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.02k|         }
  159|    155|         else {
  160|    155|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    155|         }
  162|  2.18k|         (void)m( result );
  163|  2.18k|         return result;
  164|  2.18k|      }
  165|  2.18k|   }
_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.18k|      {
   73|  2.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|  2.18k|         else {
   84|  2.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.18k|      {
   59|  2.18k|         return Rule::match( in );
   60|  2.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   854k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   854k|      else {
  108|   854k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   854k|         using iterator_t = typename ParseInput::iterator_t;
  111|   854k|         constexpr bool has_apply_void = 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|   854k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   854k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 854k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   854k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   854k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   854k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   854k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   854k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   854k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   854k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   854k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   854k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   854k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   854k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 854k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   854k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   854k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   854k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   854k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 852k, False: 1.66k]
  ------------------
  143|   852k|            if constexpr( has_apply_void ) {
  144|   852k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   852k|         }
  156|   854k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 852k, False: 1.67k]
  ------------------
  157|   852k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   852k|         }
  159|  1.67k|         else {
  160|  1.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.67k|         }
  162|   854k|         (void)m( result );
  163|   854k|         return result;
  164|   854k|      }
  165|   854k|   }
_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|   854k|      {
   73|   854k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   854k|         else {
   84|   854k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   854k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   854k|      }
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|   854k|      {
   44|   854k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   854k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   854k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   854k|      else {
  108|   854k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   854k|         using iterator_t = typename ParseInput::iterator_t;
  111|   854k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   854k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   854k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   854k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   854k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   854k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   854k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   854k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   854k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   854k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   854k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   854k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   854k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   854k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   854k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   854k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   854k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   854k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 852k, False: 1.59k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   852k|            else if constexpr( has_apply0_bool ) {
  153|   852k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   852k|            }
  155|   852k|         }
  156|   854k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 852k, False: 1.59k]
  ------------------
  157|   852k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   852k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|   854k|         (void)m( result );
  163|   854k|         return result;
  164|   854k|      }
  165|   854k|   }
_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|   854k|      {
   73|   854k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   854k|         else {
   84|   854k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   854k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   854k|      }
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|   854k|      {
   44|   854k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   854k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.70M|      else {
  108|  1.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.70M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.70M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.70M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.70M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.74k, False: 1.70M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.74k|            else if constexpr( has_apply0_bool ) {
  153|  1.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.74k|            }
  155|  1.74k|         }
  156|  1.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.74k, False: 1.70M]
  ------------------
  157|  1.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.74k|         }
  159|  1.70M|         else {
  160|  1.70M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70M|         }
  162|  1.70M|         (void)m( result );
  163|  1.70M|         return result;
  164|  1.70M|      }
  165|  1.70M|   }
_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.70M|      {
   73|  1.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.70M|         else {
   84|  1.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.70M|      {
   44|  1.70M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.70M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.71M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.71M|      else {
  108|  1.71M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.71M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.71M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.71M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.71M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.71M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.71M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.71M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.71M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.71M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.71M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.71M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.71M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.71M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.71M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.71M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.71M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.71M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.71M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.71M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.11k, False: 1.70M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.11k|            else if constexpr( has_apply0_bool ) {
  153|  7.11k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.11k|            }
  155|  7.11k|         }
  156|  1.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.11k, False: 1.70M]
  ------------------
  157|  7.11k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.11k|         }
  159|  1.70M|         else {
  160|  1.70M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70M|         }
  162|  1.71M|         (void)m( result );
  163|  1.71M|         return result;
  164|  1.71M|      }
  165|  1.71M|   }
_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.71M|      {
   73|  1.71M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.71M|         else {
   84|  1.71M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.71M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.71M|      }
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.71M|      {
   59|  1.71M|         return Rule::match( in );
   60|  1.71M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.70M|      else {
  108|  1.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.70M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.70M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.70M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.70M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70M, False: 1.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.70M|            else if constexpr( has_apply0_bool ) {
  153|  1.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70M|            }
  155|  1.70M|         }
  156|  1.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70M, False: 1.61k]
  ------------------
  157|  1.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70M|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  1.70M|         (void)m( result );
  163|  1.70M|         return result;
  164|  1.70M|      }
  165|  1.70M|   }
_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.70M|      {
   73|  1.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.70M|         else {
   84|  1.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.70M|      {
   59|  1.70M|         return Rule::match( in );
   60|  1.70M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   852k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   852k|      else {
  108|   852k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   852k|         using iterator_t = typename ParseInput::iterator_t;
  111|   852k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   852k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   852k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   852k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   852k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   852k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   852k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   852k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   852k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   852k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   852k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   852k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   852k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   852k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   852k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   852k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   852k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   852k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 852k, False: 51]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   852k|            else if constexpr( has_apply0_bool ) {
  153|   852k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   852k|            }
  155|   852k|         }
  156|   852k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 852k, False: 51]
  ------------------
  157|   852k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   852k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|   852k|         (void)m( result );
  163|   852k|         return result;
  164|   852k|      }
  165|   852k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   852k|      {
   73|   852k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   852k|         else {
   84|   852k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   852k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   852k|      }
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|   852k|      {
   59|   852k|         return Rule::match( in );
   60|   852k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   852k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   852k|      else {
  108|   852k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   852k|         using iterator_t = typename ParseInput::iterator_t;
  111|   852k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   852k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   852k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   852k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   852k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   852k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   852k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   852k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   852k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   852k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   852k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   852k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   852k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   852k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   852k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   852k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   852k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   852k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 852k, False: 17]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   852k|            else if constexpr( has_apply0_bool ) {
  153|   852k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   852k|            }
  155|   852k|         }
  156|   852k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 852k, False: 17]
  ------------------
  157|   852k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   852k|         }
  159|     17|         else {
  160|     17|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     17|         }
  162|   852k|         (void)m( result );
  163|   852k|         return result;
  164|   852k|      }
  165|   852k|   }
_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|   852k|      {
   73|   852k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   852k|         else {
   84|   852k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   852k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   852k|      }
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|   852k|      {
   44|   852k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   852k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  37.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  37.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.94k, False: 34.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.94k|            else if constexpr( has_apply0_bool ) {
  153|  2.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.94k|            }
  155|  2.94k|         }
  156|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.94k, False: 34.7k]
  ------------------
  157|  2.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.94k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  37.7k|      {
   73|  37.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  37.7k|         else {
   84|  37.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  37.7k|      {
   44|  37.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.7k|      }
_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|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  37.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  37.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.94k, False: 34.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.94k|            else if constexpr( has_apply0_bool ) {
  153|  2.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.94k|            }
  155|  2.94k|         }
  156|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.94k, False: 34.7k]
  ------------------
  157|  2.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.94k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_ZN3tao5pegtl8internal20match_control_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|  37.7k|      {
   73|  37.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  37.7k|         else {
   84|  37.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_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|  37.7k|      {
   44|  37.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  37.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 37.7k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  37.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  37.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 37.7k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.67k, False: 34.0k]
  ------------------
  143|  3.67k|            if constexpr( has_apply_void ) {
  144|  3.67k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.67k|         }
  156|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 34.0k]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|  34.0k|         else {
  160|  34.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.0k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_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|  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_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|  37.7k|      {
   59|  37.7k|         return Rule::match( in );
   60|  37.7k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   320k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   320k|      else {
  108|   320k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   320k|         using iterator_t = typename ParseInput::iterator_t;
  111|   320k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   320k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   320k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   320k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   320k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   320k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   320k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   320k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   320k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   320k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   320k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   320k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   320k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   320k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   320k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   320k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   320k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   320k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 318k, False: 1.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   318k|            else if constexpr( has_apply0_bool ) {
  153|   318k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   318k|            }
  155|   318k|         }
  156|   320k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 318k, False: 1.86k]
  ------------------
  157|   318k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   318k|         }
  159|  1.86k|         else {
  160|  1.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.86k|         }
  162|   320k|         (void)m( result );
  163|   320k|         return result;
  164|   320k|      }
  165|   320k|   }
_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|   320k|      {
   73|   320k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   320k|         else {
   84|   320k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   320k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   320k|      }
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|   320k|      {
   44|   320k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   320k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   320k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   320k|      else {
  108|   320k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   320k|         using iterator_t = typename ParseInput::iterator_t;
  111|   320k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   320k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   320k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   320k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   320k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   320k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   320k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   320k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   320k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   320k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   320k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   320k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   320k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   320k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   320k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   320k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   320k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   320k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 318k, False: 1.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   318k|            else if constexpr( has_apply0_bool ) {
  153|   318k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   318k|            }
  155|   318k|         }
  156|   320k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 318k, False: 1.86k]
  ------------------
  157|   318k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   318k|         }
  159|  1.86k|         else {
  160|  1.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.86k|         }
  162|   320k|         (void)m( result );
  163|   320k|         return result;
  164|   320k|      }
  165|   320k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   320k|      {
   73|   320k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   320k|         else {
   84|   320k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   320k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   320k|      }
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|   320k|      {
   59|   320k|         return Rule::match( in );
   60|   320k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   328k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   328k|      else {
  108|   328k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   328k|         using iterator_t = typename ParseInput::iterator_t;
  111|   328k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   328k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   328k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   328k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   328k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   328k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   328k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   328k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   328k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   328k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   328k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   328k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   328k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   328k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   328k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   328k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   328k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   328k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.16k, False: 323k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.16k|            else if constexpr( has_apply0_bool ) {
  153|  5.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.16k|            }
  155|  5.16k|         }
  156|   328k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.16k, False: 323k]
  ------------------
  157|  5.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.16k|         }
  159|   323k|         else {
  160|   323k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   323k|         }
  162|   328k|         (void)m( result );
  163|   328k|         return result;
  164|   328k|      }
  165|   328k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   328k|      {
   73|   328k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   328k|         else {
   84|   328k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   328k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   328k|      }
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|   328k|      {
   59|   328k|         return Rule::match( in );
   60|   328k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.94k, False: 714]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.94k|            else if constexpr( has_apply0_bool ) {
  153|  2.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.94k|            }
  155|  2.94k|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.94k, False: 714]
  ------------------
  157|  2.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.94k|         }
  159|    714|         else {
  160|    714|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    714|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.28k, False: 1.37k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.28k|            else if constexpr( has_apply0_bool ) {
  153|  2.28k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.28k|            }
  155|  2.28k|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.28k, False: 1.37k]
  ------------------
  157|  2.28k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.28k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.65k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.65k|            else if constexpr( has_apply0_bool ) {
  153|  3.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.65k|            }
  155|  3.65k|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.65k, False: 0]
  ------------------
  157|  3.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.65k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|  3.65k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.65k|         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.65k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.65k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.65k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.68k, False: 1.96k]
  ------------------
  143|  1.68k|            if constexpr( has_apply_void ) {
  144|  1.68k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.68k|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.68k, False: 1.96k]
  ------------------
  157|  1.68k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.68k|         }
  159|  1.96k|         else {
  160|  1.96k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.96k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, 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|    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.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 3.44k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  3.44k|         else {
  160|  3.44k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.44k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.65k|      {
   59|  3.65k|         return Rule::match( in );
   60|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.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: 409, 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|    409|            else if constexpr( has_apply0_bool ) {
  153|    409|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    409|            }
  155|    409|         }
  156|  3.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 409, False: 3.03k]
  ------------------
  157|    409|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    409|         }
  159|  3.03k|         else {
  160|  3.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.03k|         }
  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_12name_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_12name_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_12name_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: 271, 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|    271|            else if constexpr( has_apply0_bool ) {
  153|    271|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    271|            }
  155|    271|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 271, False: 2.76k]
  ------------------
  157|    271|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    271|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.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_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.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_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.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.76k|      else {
  108|  2.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 229, 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|    229|            else if constexpr( has_apply0_bool ) {
  153|    229|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    229|            }
  155|    229|         }
  156|  2.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 229, False: 2.53k]
  ------------------
  157|    229|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    229|         }
  159|  2.53k|         else {
  160|  2.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.53k|         }
  162|  2.76k|         (void)m( result );
  163|  2.76k|         return result;
  164|  2.76k|      }
  165|  2.76k|   }
_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.76k|      {
   73|  2.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.76k|         else {
   84|  2.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.76k|      {
   59|  2.76k|         return Rule::match( in );
   60|  2.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_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: 361, False: 2.17k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    361|            else if constexpr( has_apply0_bool ) {
  153|    361|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    361|            }
  155|    361|         }
  156|  2.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 361, False: 2.17k]
  ------------------
  157|    361|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    361|         }
  159|  2.17k|         else {
  160|  2.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.17k|         }
  162|  2.53k|         (void)m( result );
  163|  2.53k|         return result;
  164|  2.53k|      }
  165|  2.53k|   }
_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.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_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.53k|      {
   59|  2.53k|         return Rule::match( in );
   60|  2.53k|      }
_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.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.17k|      else {
  108|  2.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 204, False: 1.96k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 1.96k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  1.96k|         else {
  160|  1.96k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.96k|         }
  162|  2.17k|         (void)m( result );
  163|  2.17k|         return result;
  164|  2.17k|      }
  165|  2.17k|   }
_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.17k|      {
   73|  2.17k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.17k|         else {
   84|  2.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.17k|      {
   59|  2.17k|         return Rule::match( in );
   60|  2.17k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49k, False: 1.16k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.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.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49k, False: 1.16k]
  ------------------
  157|  2.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49k|         }
  159|  1.16k|         else {
  160|  1.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.16k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.65k|      {
   73|  3.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.65k|      {
   59|  3.65k|         return Rule::match( in );
   60|  3.65k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.91k|      else {
  108|  4.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.91k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.91k|            else if constexpr( has_apply0_bool ) {
  153|  4.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.91k|            }
  155|  4.91k|         }
  156|  4.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.91k, False: 0]
  ------------------
  157|  4.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.91k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.91k|         (void)m( result );
  163|  4.91k|         return result;
  164|  4.91k|      }
  165|  4.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.91k|      {
   73|  4.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|  4.91k|         else {
   84|  4.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.91k|      {
   44|  4.91k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.91k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.49k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.49k|      else {
  108|  2.49k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.49k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.49k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.49k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.49k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.49k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.49k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.49k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.49k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.49k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.49k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.49k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.42k, 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.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.49k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.42k, False: 69]
  ------------------
  157|  2.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.42k|         }
  159|     69|         else {
  160|     69|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     69|         }
  162|  2.49k|         (void)m( result );
  163|  2.49k|         return result;
  164|  2.49k|      }
  165|  2.49k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.49k|      {
   73|  2.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|  2.49k|         else {
   84|  2.49k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.49k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.49k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.49k|      {
   44|  2.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.49k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.44k|   {
  104|  2.44k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.44k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.44k|      {
   44|  2.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.44k|      }
_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|   315k|   {
  104|   315k|      if constexpr( !Control< Rule >::enable ) {
  105|   315k|         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|   315k|   }
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|   315k|      {
   44|   315k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   315k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_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.28k, False: 143]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.28k|            else if constexpr( has_apply0_bool ) {
  153|  2.28k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.28k|            }
  155|  2.28k|         }
  156|  2.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.28k, False: 143]
  ------------------
  157|  2.28k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.28k|         }
  159|    143|         else {
  160|    143|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    143|         }
  162|  2.42k|         (void)m( result );
  163|  2.42k|         return result;
  164|  2.42k|      }
  165|  2.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_modeE0ETtTpTyEN8usbguard10RuleParser12name_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   317k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   317k|      else {
  108|   317k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   317k|         using iterator_t = typename ParseInput::iterator_t;
  111|   317k|         constexpr bool has_apply_void = 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|   317k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   317k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 317k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   317k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   317k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   317k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   317k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   317k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   317k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   317k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   317k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   317k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   317k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   317k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 317k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   317k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   317k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   317k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   317k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 315k, False: 1.29k]
  ------------------
  143|   315k|            if constexpr( has_apply_void ) {
  144|   315k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   315k|         }
  156|   317k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 315k, False: 1.37k]
  ------------------
  157|   315k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   315k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|   317k|         (void)m( result );
  163|   317k|         return result;
  164|   317k|      }
  165|   317k|   }
_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|   317k|      {
   73|   317k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   317k|         else {
   84|   317k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   317k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   317k|      }
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|   317k|      {
   44|   317k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   317k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   317k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   317k|      else {
  108|   317k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   317k|         using iterator_t = typename ParseInput::iterator_t;
  111|   317k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   317k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   317k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   317k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   317k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   317k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   317k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   317k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   317k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   317k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   317k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   317k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   317k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   317k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   317k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   317k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   317k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   317k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 316k, False: 996]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   316k|            else if constexpr( has_apply0_bool ) {
  153|   316k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   316k|            }
  155|   316k|         }
  156|   317k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 316k, False: 996]
  ------------------
  157|   316k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   316k|         }
  159|    996|         else {
  160|    996|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    996|         }
  162|   317k|         (void)m( result );
  163|   317k|         return result;
  164|   317k|      }
  165|   317k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   317k|      {
   73|   317k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   317k|         else {
   84|   317k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   317k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   317k|      }
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|   317k|      {
   59|   317k|         return Rule::match( in );
   60|   317k|      }
_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|   316k|   {
  104|   316k|      if constexpr( !Control< Rule >::enable ) {
  105|   316k|         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|   316k|   }
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|   316k|      {
   44|   316k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   316k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   316k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   316k|      else {
  108|   316k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   316k|         using iterator_t = typename ParseInput::iterator_t;
  111|   316k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   316k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   316k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   316k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   316k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   316k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   316k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   316k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   316k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   316k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   316k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   316k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   316k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   316k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   316k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   316k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   316k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   316k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 315k, False: 299]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   315k|            else if constexpr( has_apply0_bool ) {
  153|   315k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   315k|            }
  155|   315k|         }
  156|   316k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 315k, False: 299]
  ------------------
  157|   315k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   315k|         }
  159|    299|         else {
  160|    299|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    299|         }
  162|   316k|         (void)m( result );
  163|   316k|         return result;
  164|   316k|      }
  165|   316k|   }
_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|   316k|      {
   73|   316k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   316k|         else {
   84|   316k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   316k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   316k|      }
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|   316k|      {
   44|   316k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   316k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  15.9M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.9M|      else {
  108|  15.9M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.9M|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.9M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.9M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.9M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.9M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.9M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.9M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.9M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.9M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.9M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.9M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 315k, False: 15.6M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   315k|            else if constexpr( has_apply0_bool ) {
  153|   315k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   315k|            }
  155|   315k|         }
  156|  15.9M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 315k, False: 15.6M]
  ------------------
  157|   315k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   315k|         }
  159|  15.6M|         else {
  160|  15.6M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.6M|         }
  162|  15.9M|         (void)m( result );
  163|  15.9M|         return result;
  164|  15.9M|      }
  165|  15.9M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  15.9M|      {
   73|  15.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|  15.9M|         else {
   84|  15.9M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.9M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.9M|      }
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|  15.9M|      {
   59|  15.9M|         return Rule::match( in );
   60|  15.9M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.6M|      else {
  108|  15.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 15.6M, False: 299]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  15.6M|            else if constexpr( has_apply0_bool ) {
  153|  15.6M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  15.6M|            }
  155|  15.6M|         }
  156|  15.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 15.6M, False: 299]
  ------------------
  157|  15.6M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  15.6M|         }
  159|    299|         else {
  160|    299|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    299|         }
  162|  15.6M|         (void)m( result );
  163|  15.6M|         return result;
  164|  15.6M|      }
  165|  15.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  15.6M|      {
   73|  15.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|  15.6M|         else {
   84|  15.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6M|      }
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|  15.6M|      {
   44|  15.6M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  15.6M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.6M|      else {
  108|  15.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 239k, False: 15.3M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   239k|            else if constexpr( has_apply0_bool ) {
  153|   239k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   239k|            }
  155|   239k|         }
  156|  15.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 239k, False: 15.3M]
  ------------------
  157|   239k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   239k|         }
  159|  15.3M|         else {
  160|  15.3M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.3M|         }
  162|  15.6M|         (void)m( result );
  163|  15.6M|         return result;
  164|  15.6M|      }
  165|  15.6M|   }
_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|  15.6M|      {
   73|  15.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|  15.6M|         else {
   84|  15.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6M|      }
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|  15.6M|      {
   44|  15.6M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  15.6M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.6M|      else {
  108|  15.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 239k, False: 15.3M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   239k|            else if constexpr( has_apply0_bool ) {
  153|   239k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   239k|            }
  155|   239k|         }
  156|  15.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 239k, False: 15.3M]
  ------------------
  157|   239k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   239k|         }
  159|  15.3M|         else {
  160|  15.3M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.3M|         }
  162|  15.6M|         (void)m( result );
  163|  15.6M|         return result;
  164|  15.6M|      }
  165|  15.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  15.6M|      {
   73|  15.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|  15.6M|         else {
   84|  15.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6M|      }
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|  15.6M|      {
   59|  15.6M|         return Rule::match( in );
   60|  15.6M|      }
_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|   239k|   {
  104|   239k|      if constexpr( !Control< Rule >::enable ) {
  105|   239k|         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|   239k|   }
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|   239k|      {
   44|   239k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   239k|      }
_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|   239k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   239k|      else {
  108|   239k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   239k|         using iterator_t = typename ParseInput::iterator_t;
  111|   239k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   239k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   239k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   239k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   239k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   239k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   239k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   239k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   239k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   239k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   239k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   239k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   239k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   239k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   239k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   239k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   239k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   239k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 239k, False: 92]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   239k|            else if constexpr( has_apply0_bool ) {
  153|   239k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   239k|            }
  155|   239k|         }
  156|   239k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 239k, False: 92]
  ------------------
  157|   239k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   239k|         }
  159|     92|         else {
  160|     92|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     92|         }
  162|   239k|         (void)m( result );
  163|   239k|         return result;
  164|   239k|      }
  165|   239k|   }
_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|   239k|      {
   73|   239k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   239k|         else {
   84|   239k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   239k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   239k|      }
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|   239k|      {
   44|   239k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   239k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   239k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   239k|      else {
  108|   239k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   239k|         using iterator_t = typename ParseInput::iterator_t;
  111|   239k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   239k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   239k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   239k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   239k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   239k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   239k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   239k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   239k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   239k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   239k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   239k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   239k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   239k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   239k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   239k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   239k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   239k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 106k, False: 133k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   239k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 106k, False: 133k]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|   133k|         else {
  160|   133k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   133k|         }
  162|   239k|         (void)m( result );
  163|   239k|         return result;
  164|   239k|      }
  165|   239k|   }
_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|   239k|      {
   73|   239k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   239k|         else {
   84|   239k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   239k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   239k|      }
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|   239k|      {
   44|   239k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   239k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   239k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   239k|      else {
  108|   239k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   239k|         using iterator_t = typename ParseInput::iterator_t;
  111|   239k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   239k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   239k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   239k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   239k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   239k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   239k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   239k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   239k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   239k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   239k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   239k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   239k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   239k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   239k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   239k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   239k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   239k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 106k, False: 133k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   239k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 106k, False: 133k]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|   133k|         else {
  160|   133k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   133k|         }
  162|   239k|         (void)m( result );
  163|   239k|         return result;
  164|   239k|      }
  165|   239k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   239k|      {
   73|   239k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   239k|         else {
   84|   239k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   239k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   239k|      }
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|   239k|      {
   59|   239k|         return Rule::match( in );
   60|   239k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   106k|   {
  104|   106k|      if constexpr( !Control< Rule >::enable ) {
  105|   106k|         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|   106k|   }
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|   106k|      {
   44|   106k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   106k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 27]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   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: 27]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|     27|         else {
  160|     27|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     27|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_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|   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_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|   106k|      {
   44|   106k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   106k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   212k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   212k|      else {
  108|   212k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   212k|         using iterator_t = typename ParseInput::iterator_t;
  111|   212k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   212k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   212k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   212k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   212k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   212k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   212k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   212k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   212k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   212k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   212k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   212k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   212k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   212k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   212k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   212k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   212k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   212k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212k, False: 27]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   212k|            else if constexpr( has_apply0_bool ) {
  153|   212k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   212k|            }
  155|   212k|         }
  156|   212k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212k, False: 27]
  ------------------
  157|   212k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   212k|         }
  159|     27|         else {
  160|     27|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     27|         }
  162|   212k|         (void)m( result );
  163|   212k|         return result;
  164|   212k|      }
  165|   212k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   212k|      {
   73|   212k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   212k|         else {
   84|   212k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   212k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   212k|      }
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|   212k|      {
   59|   212k|         return Rule::match( in );
   60|   212k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   133k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   133k|      else {
  108|   133k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   133k|         using iterator_t = typename ParseInput::iterator_t;
  111|   133k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   133k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   133k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   133k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   133k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   133k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   133k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   133k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   133k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   133k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   133k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   133k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   133k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   133k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   133k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   133k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   133k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   133k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.9k, False: 98.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|  34.9k|            else if constexpr( has_apply0_bool ) {
  153|  34.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.9k|            }
  155|  34.9k|         }
  156|   133k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.9k, False: 98.5k]
  ------------------
  157|  34.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.9k|         }
  159|  98.5k|         else {
  160|  98.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  98.5k|         }
  162|   133k|         (void)m( result );
  163|   133k|         return result;
  164|   133k|      }
  165|   133k|   }
_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|   133k|      {
   73|   133k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   133k|         else {
   84|   133k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   133k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   133k|      }
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|   133k|      {
   44|   133k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   133k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   173k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   173k|      else {
  108|   173k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   173k|         using iterator_t = typename ParseInput::iterator_t;
  111|   173k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   173k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   173k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   173k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   173k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   173k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   173k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   173k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   173k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   173k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   173k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   173k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   173k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   173k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   173k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   173k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   173k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   173k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.3k, False: 131k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   173k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.3k, False: 131k]
  ------------------
  157|  42.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.3k|         }
  159|   131k|         else {
  160|   131k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   131k|         }
  162|   173k|         (void)m( result );
  163|   173k|         return result;
  164|   173k|      }
  165|   173k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   173k|      {
   73|   173k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   173k|         else {
   84|   173k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   173k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   173k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   173k|      {
   59|   173k|         return Rule::match( in );
   60|   173k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  34.9k|   {
  104|  34.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  34.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  34.9k|   }
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|  34.9k|      {
   44|  34.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.9k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  34.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.9k|      else {
  108|  34.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.9k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  34.9k|            else if constexpr( has_apply0_bool ) {
  153|  34.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.9k|            }
  155|  34.9k|         }
  156|  34.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.9k, False: 0]
  ------------------
  157|  34.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  34.9k|         (void)m( result );
  163|  34.9k|         return result;
  164|  34.9k|      }
  165|  34.9k|   }
_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|  34.9k|      {
   73|  34.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|  34.9k|         else {
   84|  34.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.9k|      }
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|  34.9k|      {
   44|  34.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  98.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  98.5k|      else {
  108|  98.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  98.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  98.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|  98.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|  98.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|  98.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|  98.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|  98.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|  98.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  98.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  98.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  98.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|  98.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  98.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  98.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|  98.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  98.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  98.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  98.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  98.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 94.1k, False: 4.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|  94.1k|            else if constexpr( has_apply0_bool ) {
  153|  94.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  94.1k|            }
  155|  94.1k|         }
  156|  98.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 94.1k, False: 4.37k]
  ------------------
  157|  94.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  94.1k|         }
  159|  4.37k|         else {
  160|  4.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.37k|         }
  162|  98.5k|         (void)m( result );
  163|  98.5k|         return result;
  164|  98.5k|      }
  165|  98.5k|   }
_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|  98.5k|      {
   73|  98.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|  98.5k|         else {
   84|  98.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  98.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  98.5k|      }
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|  98.5k|      {
   59|  98.5k|         return Rule::match( in );
   60|  98.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.37k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.37k|      else {
  108|  4.37k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.37k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.37k|         constexpr bool has_apply_void = enable_action && internal::has_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.37k|         constexpr bool has_apply_bool = enable_action && internal::has_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.37k|         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.37k|         constexpr bool has_apply0_void = enable_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.37k|         constexpr bool has_apply0_bool = enable_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.37k|         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.37k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.37k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.37k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.37k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.37k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.37k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.37k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.37k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.37k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.37k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.37k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.37k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.30k, False: 65]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.30k|            else if constexpr( has_apply0_bool ) {
  153|  4.30k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.30k|            }
  155|  4.30k|         }
  156|  4.37k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.30k, False: 65]
  ------------------
  157|  4.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.30k|         }
  159|     65|         else {
  160|     65|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     65|         }
  162|  4.37k|         (void)m( result );
  163|  4.37k|         return result;
  164|  4.37k|      }
  165|  4.37k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.37k|      {
   73|  4.37k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.37k|         else {
   84|  4.37k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.37k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.37k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.37k|      {
   59|  4.37k|         return Rule::match( in );
   60|  4.37k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  15.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.3M|      else {
  108|  15.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 15.3M, False: 207]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  15.3M|            else if constexpr( has_apply0_bool ) {
  153|  15.3M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  15.3M|            }
  155|  15.3M|         }
  156|  15.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 15.3M, False: 207]
  ------------------
  157|  15.3M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  15.3M|         }
  159|    207|         else {
  160|    207|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    207|         }
  162|  15.3M|         (void)m( result );
  163|  15.3M|         return result;
  164|  15.3M|      }
  165|  15.3M|   }
_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|  15.3M|      {
   73|  15.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|  15.3M|         else {
   84|  15.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.3M|      }
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|  15.3M|      {
   59|  15.3M|         return Rule::match( in );
   60|  15.3M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  34.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.3k|      else {
  108|  34.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 30.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.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  34.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 30.9k]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|  30.9k|         else {
  160|  30.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.9k|         }
  162|  34.3k|         (void)m( result );
  163|  34.3k|         return result;
  164|  34.3k|      }
  165|  34.3k|   }
_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|  34.3k|      {
   73|  34.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|  34.3k|         else {
   84|  34.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.3k|      }
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|  34.3k|      {
   44|  34.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.3k|      }
_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|  34.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.3k|      else {
  108|  34.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 30.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.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  34.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 30.9k]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|  30.9k|         else {
  160|  30.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.9k|         }
  162|  34.3k|         (void)m( result );
  163|  34.3k|         return result;
  164|  34.3k|      }
  165|  34.3k|   }
_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|  34.3k|      {
   73|  34.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|  34.3k|         else {
   84|  34.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.3k|      }
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|  34.3k|      {
   44|  34.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  34.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.3k|      else {
  108|  34.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 34.3k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  34.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|  34.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|  34.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|  34.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 34.3k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.17k, False: 30.2k]
  ------------------
  143|  4.17k|            if constexpr( has_apply_void ) {
  144|  4.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|  4.17k|         }
  156|  34.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.16k, False: 30.2k]
  ------------------
  157|  4.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.16k|         }
  159|  30.2k|         else {
  160|  30.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.2k|         }
  162|  34.3k|         (void)m( result );
  163|  34.3k|         return result;
  164|  34.3k|      }
  165|  34.3k|   }
_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|  34.3k|      {
   73|  34.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|  34.3k|         else {
   84|  34.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.3k|      }
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|  34.3k|      {
   59|  34.3k|         return Rule::match( in );
   60|  34.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.9k|      else {
  108|  11.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  11.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.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|  11.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|  11.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|  11.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|  11.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.0k, False: 1.93k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.0k|            else if constexpr( has_apply0_bool ) {
  153|  10.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.0k|            }
  155|  10.0k|         }
  156|  11.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.0k, False: 1.93k]
  ------------------
  157|  10.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.0k|         }
  159|  1.93k|         else {
  160|  1.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.93k|         }
  162|  11.9k|         (void)m( result );
  163|  11.9k|         return result;
  164|  11.9k|      }
  165|  11.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  11.9k|      {
   73|  11.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|  11.9k|         else {
   84|  11.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.9k|      {
   44|  11.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  11.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.9k|      else {
  108|  11.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  11.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.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|  11.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|  11.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|  11.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|  11.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  11.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.0k, False: 1.93k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.0k|            else if constexpr( has_apply0_bool ) {
  153|  10.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.0k|            }
  155|  10.0k|         }
  156|  11.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.0k, False: 1.93k]
  ------------------
  157|  10.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.0k|         }
  159|  1.93k|         else {
  160|  1.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.93k|         }
  162|  11.9k|         (void)m( result );
  163|  11.9k|         return result;
  164|  11.9k|      }
  165|  11.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  11.9k|      {
   73|  11.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|  11.9k|         else {
   84|  11.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.9k|      {
   59|  11.9k|         return Rule::match( in );
   60|  11.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  20.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.5k|      else {
  108|  20.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.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|  20.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|  20.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|  20.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|  20.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|  20.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|  20.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.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|  20.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.97k, False: 15.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.97k|            else if constexpr( has_apply0_bool ) {
  153|  4.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.97k|            }
  155|  4.97k|         }
  156|  20.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.97k, False: 15.5k]
  ------------------
  157|  4.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.97k|         }
  159|  15.5k|         else {
  160|  15.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.5k|         }
  162|  20.5k|         (void)m( result );
  163|  20.5k|         return result;
  164|  20.5k|      }
  165|  20.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  20.5k|      {
   73|  20.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|  20.5k|         else {
   84|  20.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  20.5k|      {
   59|  20.5k|         return Rule::match( in );
   60|  20.5k|      }
_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.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, 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.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 722]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|    722|         else {
  160|    722|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    722|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   44|  4.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.14k|      }
_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.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 1.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|  2.58k|            else if constexpr( has_apply0_bool ) {
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 1.56k]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|  1.56k|         else {
  160|  1.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.56k|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   44|  4.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.14k|      }
_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.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.14k, 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.14k|            else if constexpr( has_apply0_bool ) {
  153|  4.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.14k|            }
  155|  4.14k|         }
  156|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.14k, False: 0]
  ------------------
  157|  4.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.14k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   44|  4.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.14k|      }
_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.14k|   {
  104|  4.14k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.14k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.14k|   }
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.14k|      {
   44|  4.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.14k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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): [True: 0, Folded]
  ------------------
  112|  4.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|  4.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.14k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.14k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.47k, False: 2.67k]
  ------------------
  143|  1.47k|            if constexpr( has_apply_void ) {
  144|  1.47k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.47k|         }
  156|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.47k, False: 2.67k]
  ------------------
  157|  1.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.47k|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   44|  4.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.14k|      }
_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.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 211, False: 3.93k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 211, False: 3.93k]
  ------------------
  157|    211|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    211|         }
  159|  3.93k|         else {
  160|  3.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.93k|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   59|  4.14k|         return Rule::match( in );
   60|  4.14k|      }
_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.93k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.93k|      else {
  108|  3.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.93k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.93k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.93k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.93k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.93k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.93k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 339, False: 3.59k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    339|            else if constexpr( has_apply0_bool ) {
  153|    339|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    339|            }
  155|    339|         }
  156|  3.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 339, False: 3.59k]
  ------------------
  157|    339|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    339|         }
  159|  3.59k|         else {
  160|  3.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.59k|         }
  162|  3.93k|         (void)m( result );
  163|  3.93k|         return result;
  164|  3.93k|      }
  165|  3.93k|   }
_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.93k|      {
   73|  3.93k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.93k|         else {
   84|  3.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.93k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.93k|      {
   59|  3.93k|         return Rule::match( in );
   60|  3.93k|      }
_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.59k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.59k|      else {
  108|  3.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 216, False: 3.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|    216|            else if constexpr( has_apply0_bool ) {
  153|    216|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    216|            }
  155|    216|         }
  156|  3.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 216, False: 3.38k]
  ------------------
  157|    216|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    216|         }
  159|  3.38k|         else {
  160|  3.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.38k|         }
  162|  3.59k|         (void)m( result );
  163|  3.59k|         return result;
  164|  3.59k|      }
  165|  3.59k|   }
_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.59k|      {
   73|  3.59k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.59k|         else {
   84|  3.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.59k|      }
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.59k|      {
   59|  3.59k|         return Rule::match( in );
   60|  3.59k|      }
_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.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.38k|      else {
  108|  3.38k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.38k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.38k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.38k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.38k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.38k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.38k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.38k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.38k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.38k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.38k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.38k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.38k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.38k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.38k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.38k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 3.18k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    196|            else if constexpr( has_apply0_bool ) {
  153|    196|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    196|            }
  155|    196|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 3.18k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  3.18k|         else {
  160|  3.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.18k|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_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.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.38k|         else {
   84|  3.38k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.38k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.38k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.38k|      {
   59|  3.38k|         return Rule::match( in );
   60|  3.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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: 296, False: 2.89k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    296|            else if constexpr( has_apply0_bool ) {
  153|    296|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    296|            }
  155|    296|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 296, False: 2.89k]
  ------------------
  157|    296|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    296|         }
  159|  2.89k|         else {
  160|  2.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.89k|         }
  162|  3.18k|         (void)m( result );
  163|  3.18k|         return result;
  164|  3.18k|      }
  165|  3.18k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.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_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.18k|      {
   59|  3.18k|         return Rule::match( in );
   60|  3.18k|      }
_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.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 216, False: 2.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    216|            else if constexpr( has_apply0_bool ) {
  153|    216|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    216|            }
  155|    216|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 216, False: 2.67k]
  ------------------
  157|    216|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    216|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_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.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.89k|      {
   59|  2.89k|         return Rule::match( in );
   60|  2.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.14k|      else {
  108|  4.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.80k, False: 1.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.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|  4.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.80k, False: 1.34k]
  ------------------
  157|  2.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.80k|         }
  159|  1.34k|         else {
  160|  1.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.34k|         }
  162|  4.14k|         (void)m( result );
  163|  4.14k|         return result;
  164|  4.14k|      }
  165|  4.14k|   }
_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.14k|      {
   73|  4.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|  4.14k|         else {
   84|  4.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.14k|      }
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.14k|      {
   59|  4.14k|         return Rule::match( in );
   60|  4.14k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 5.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|  5.51k|            else if constexpr( has_apply0_bool ) {
  153|  5.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.51k|            }
  155|  5.51k|         }
  156|  5.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.51k, False: 0]
  ------------------
  157|  5.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.51k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.51k|         (void)m( result );
  163|  5.51k|         return result;
  164|  5.51k|      }
  165|  5.51k|   }
_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.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_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.51k|      {
   44|  5.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.51k|      }
_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.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.80k|      else {
  108|  2.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.71k, False: 89]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  2.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.71k, False: 89]
  ------------------
  157|  2.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.71k|         }
  159|     89|         else {
  160|     89|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     89|         }
  162|  2.80k|         (void)m( result );
  163|  2.80k|         return result;
  164|  2.80k|      }
  165|  2.80k|   }
_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.80k|      {
   73|  2.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|  2.80k|         else {
   84|  2.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.80k|      }
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.80k|      {
   44|  2.80k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.80k|      }
_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.73k|   {
  104|  2.73k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.73k|         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.73k|   }
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.73k|      {
   44|  2.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.73k|      }
_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.33k|   {
  104|  6.33k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.33k|   }
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.33k|      {
   44|  6.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.33k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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.58k, False: 128]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.58k|            else if constexpr( has_apply0_bool ) {
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  2.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 128]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|    128|         else {
  160|    128|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    128|         }
  162|  2.71k|         (void)m( result );
  163|  2.71k|         return result;
  164|  2.71k|      }
  165|  2.71k|   }
_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.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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.71k|      {
   59|  2.71k|         return Rule::match( in );
   60|  2.71k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.78k|      else {
  108|  8.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.78k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.78k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.78k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.78k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.78k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.78k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.24k, False: 1.53k]
  ------------------
  143|  7.24k|            if constexpr( has_apply_void ) {
  144|  7.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|  7.24k|         }
  156|  8.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.17k, False: 1.60k]
  ------------------
  157|  7.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.17k|         }
  159|  1.60k|         else {
  160|  1.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60k|         }
  162|  8.78k|         (void)m( result );
  163|  8.78k|         return result;
  164|  8.78k|      }
  165|  8.78k|   }
_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.78k|      {
   73|  8.78k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.78k|         else {
   84|  8.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.78k|      }
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.78k|      {
   44|  8.78k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.78k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.78k|      else {
  108|  8.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.78k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.78k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.78k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.78k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.54k, False: 1.23k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.54k|            else if constexpr( has_apply0_bool ) {
  153|  7.54k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.54k|            }
  155|  7.54k|         }
  156|  8.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.54k, False: 1.23k]
  ------------------
  157|  7.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.54k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  8.78k|         (void)m( result );
  163|  8.78k|         return result;
  164|  8.78k|      }
  165|  8.78k|   }
_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.78k|      {
   73|  8.78k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.78k|         else {
   84|  8.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.78k|      }
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.78k|      {
   59|  8.78k|         return Rule::match( in );
   60|  8.78k|      }
_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.54k|   {
  104|  7.54k|      if constexpr( !Control< Rule >::enable ) {
  105|  7.54k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  7.54k|   }
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.54k|      {
   44|  7.54k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.54k|      }
_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.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.54k|      else {
  108|  7.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.24k, False: 297]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  7.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.24k|            }
  155|  7.24k|         }
  156|  7.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.24k, False: 297]
  ------------------
  157|  7.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.24k|         }
  159|    297|         else {
  160|    297|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    297|         }
  162|  7.54k|         (void)m( result );
  163|  7.54k|         return result;
  164|  7.54k|      }
  165|  7.54k|   }
_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.54k|      {
   73|  7.54k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.54k|         else {
   84|  7.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.54k|      }
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.54k|      {
   44|  7.54k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.54k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.28M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.28M|      else {
  108|  9.28M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.28M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.28M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.28M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.28M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.28M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.28M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.28M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.28M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.28M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.28M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.28M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.28M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.28M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.28M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.28M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.28M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.28M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.28M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.28M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.24k, False: 9.27M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  7.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.24k|            }
  155|  7.24k|         }
  156|  9.28M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.24k, False: 9.27M]
  ------------------
  157|  7.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.24k|         }
  159|  9.27M|         else {
  160|  9.27M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.27M|         }
  162|  9.28M|         (void)m( result );
  163|  9.28M|         return result;
  164|  9.28M|      }
  165|  9.28M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.28M|      {
   73|  9.28M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.28M|         else {
   84|  9.28M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.28M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.28M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.28M|      {
   59|  9.28M|         return Rule::match( in );
   60|  9.28M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.27M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.27M|      else {
  108|  9.27M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.27M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.27M|         constexpr bool has_apply_void = enable_action && internal::has_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.27M|         constexpr bool has_apply_bool = enable_action && internal::has_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.27M|         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.27M|         constexpr bool has_apply0_void = enable_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.27M|         constexpr bool has_apply0_bool = enable_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.27M|         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.27M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.27M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.27M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.27M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.27M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.27M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.27M|         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.27M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.27M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.27M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.27M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.27M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.27M, False: 297]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.27M|            else if constexpr( has_apply0_bool ) {
  153|  9.27M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.27M|            }
  155|  9.27M|         }
  156|  9.27M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.27M, False: 297]
  ------------------
  157|  9.27M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.27M|         }
  159|    297|         else {
  160|    297|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    297|         }
  162|  9.27M|         (void)m( result );
  163|  9.27M|         return result;
  164|  9.27M|      }
  165|  9.27M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.27M|      {
   73|  9.27M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.27M|         else {
   84|  9.27M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.27M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.27M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.27M|      {
   44|  9.27M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.27M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.27M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.27M|      else {
  108|  9.27M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.27M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.27M|         constexpr bool has_apply_void = enable_action && internal::has_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.27M|         constexpr bool has_apply_bool = enable_action && internal::has_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.27M|         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.27M|         constexpr bool has_apply0_void = enable_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.27M|         constexpr bool has_apply0_bool = enable_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.27M|         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.27M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.27M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.27M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.27M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.27M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.27M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.27M|         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.27M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.27M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.27M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.27M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.27M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 127k, False: 9.14M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   127k|            else if constexpr( has_apply0_bool ) {
  153|   127k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   127k|            }
  155|   127k|         }
  156|  9.27M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 127k, False: 9.14M]
  ------------------
  157|   127k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   127k|         }
  159|  9.14M|         else {
  160|  9.14M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.14M|         }
  162|  9.27M|         (void)m( result );
  163|  9.27M|         return result;
  164|  9.27M|      }
  165|  9.27M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.27M|      {
   73|  9.27M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.27M|         else {
   84|  9.27M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.27M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.27M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.27M|      {
   44|  9.27M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.27M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.27M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.27M|      else {
  108|  9.27M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.27M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.27M|         constexpr bool has_apply_void = enable_action && internal::has_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.27M|         constexpr bool has_apply_bool = enable_action && internal::has_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.27M|         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.27M|         constexpr bool has_apply0_void = enable_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.27M|         constexpr bool has_apply0_bool = enable_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.27M|         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.27M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.27M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.27M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.27M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.27M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.27M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.27M|         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.27M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.27M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.27M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.27M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.27M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 127k, False: 9.14M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   127k|            else if constexpr( has_apply0_bool ) {
  153|   127k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   127k|            }
  155|   127k|         }
  156|  9.27M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 127k, False: 9.14M]
  ------------------
  157|   127k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   127k|         }
  159|  9.14M|         else {
  160|  9.14M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.14M|         }
  162|  9.27M|         (void)m( result );
  163|  9.27M|         return result;
  164|  9.27M|      }
  165|  9.27M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.27M|      {
   73|  9.27M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.27M|         else {
   84|  9.27M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.27M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.27M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.27M|      {
   59|  9.27M|         return Rule::match( in );
   60|  9.27M|      }
_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|   127k|   {
  104|   127k|      if constexpr( !Control< Rule >::enable ) {
  105|   127k|         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|   127k|   }
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|   127k|      {
   44|   127k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   127k|      }
_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|   127k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   127k|      else {
  108|   127k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   127k|         using iterator_t = typename ParseInput::iterator_t;
  111|   127k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   127k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   127k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   127k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   127k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   127k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   127k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   127k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   127k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   127k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   127k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   127k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   127k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   127k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   127k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   127k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   127k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   127k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 127k, False: 96]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   127k|            else if constexpr( has_apply0_bool ) {
  153|   127k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   127k|            }
  155|   127k|         }
  156|   127k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 127k, False: 96]
  ------------------
  157|   127k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   127k|         }
  159|     96|         else {
  160|     96|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     96|         }
  162|   127k|         (void)m( result );
  163|   127k|         return result;
  164|   127k|      }
  165|   127k|   }
_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|   127k|      {
   73|   127k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   127k|         else {
   84|   127k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   127k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   127k|      }
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|   127k|      {
   44|   127k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   127k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   127k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   127k|      else {
  108|   127k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   127k|         using iterator_t = typename ParseInput::iterator_t;
  111|   127k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   127k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   127k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   127k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   127k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   127k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   127k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   127k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   127k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   127k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   127k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   127k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   127k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   127k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   127k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   127k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   127k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   127k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.9k, False: 86.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|  40.9k|            else if constexpr( has_apply0_bool ) {
  153|  40.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.9k|            }
  155|  40.9k|         }
  156|   127k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.9k, False: 86.5k]
  ------------------
  157|  40.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.9k|         }
  159|  86.5k|         else {
  160|  86.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.5k|         }
  162|   127k|         (void)m( result );
  163|   127k|         return result;
  164|   127k|      }
  165|   127k|   }
_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|   127k|      {
   73|   127k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   127k|         else {
   84|   127k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   127k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   127k|      }
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|   127k|      {
   44|   127k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   127k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   127k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   127k|      else {
  108|   127k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   127k|         using iterator_t = typename ParseInput::iterator_t;
  111|   127k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   127k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   127k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   127k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   127k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   127k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   127k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   127k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   127k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   127k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   127k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   127k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   127k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   127k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   127k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   127k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   127k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   127k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.0k, False: 86.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|  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|   127k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.0k, False: 86.5k]
  ------------------
  157|  41.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.0k|         }
  159|  86.5k|         else {
  160|  86.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.5k|         }
  162|   127k|         (void)m( result );
  163|   127k|         return result;
  164|   127k|      }
  165|   127k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   127k|      {
   73|   127k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   127k|         else {
   84|   127k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   127k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   127k|      }
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|   127k|      {
   59|   127k|         return Rule::match( in );
   60|   127k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_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_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|  41.0k|      {
   44|  41.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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.9k, False: 38]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  40.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.9k|            }
  155|  40.9k|         }
  156|  41.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.9k, False: 38]
  ------------------
  157|  40.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.9k|         }
  159|     38|         else {
  160|     38|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     38|         }
  162|  41.0k|         (void)m( result );
  163|  41.0k|         return result;
  164|  41.0k|      }
  165|  41.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|  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_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|  41.0k|      {
   44|  41.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  82.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  82.0k|      else {
  108|  82.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  82.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  82.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|  82.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|  82.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|  82.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|  82.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|  82.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|  82.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  82.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  82.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  82.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|  82.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  82.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  82.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|  82.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  82.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  82.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  82.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  82.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 82.0k, False: 38]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  82.0k|            else if constexpr( has_apply0_bool ) {
  153|  82.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  82.0k|            }
  155|  82.0k|         }
  156|  82.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 82.0k, False: 38]
  ------------------
  157|  82.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  82.0k|         }
  159|     38|         else {
  160|     38|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     38|         }
  162|  82.0k|         (void)m( result );
  163|  82.0k|         return result;
  164|  82.0k|      }
  165|  82.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  82.0k|      {
   73|  82.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|  82.0k|         else {
   84|  82.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  82.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  82.0k|      }
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|  82.0k|      {
   59|  82.0k|         return Rule::match( in );
   60|  82.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  86.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  86.5k|      else {
  108|  86.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.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|  86.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|  86.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|  86.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|  86.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|  86.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|  86.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.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|  86.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.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|  86.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  86.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.5k, False: 42.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  43.5k|            else if constexpr( has_apply0_bool ) {
  153|  43.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.5k|            }
  155|  43.5k|         }
  156|  86.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.5k, False: 42.9k]
  ------------------
  157|  43.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.5k|         }
  159|  42.9k|         else {
  160|  42.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.9k|         }
  162|  86.5k|         (void)m( result );
  163|  86.5k|         return result;
  164|  86.5k|      }
  165|  86.5k|   }
_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|  86.5k|      {
   73|  86.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|  86.5k|         else {
   84|  86.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.5k|      }
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|  86.5k|      {
   44|  86.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   135k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   135k|      else {
  108|   135k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   135k|         using iterator_t = typename ParseInput::iterator_t;
  111|   135k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   135k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   135k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   135k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   135k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   135k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   135k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   135k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   135k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   135k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   135k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   135k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   135k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   135k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   135k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   135k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   135k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   135k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 52.7k, False: 82.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|  52.7k|            else if constexpr( has_apply0_bool ) {
  153|  52.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  52.7k|            }
  155|  52.7k|         }
  156|   135k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 52.7k, False: 82.5k]
  ------------------
  157|  52.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  52.7k|         }
  159|  82.5k|         else {
  160|  82.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  82.5k|         }
  162|   135k|         (void)m( result );
  163|   135k|         return result;
  164|   135k|      }
  165|   135k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   135k|      {
   73|   135k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   135k|         else {
   84|   135k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   135k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   135k|      }
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|   135k|      {
   59|   135k|         return Rule::match( in );
   60|   135k|      }
_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|  43.5k|   {
  104|  43.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  43.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|  43.5k|   }
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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  43.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.5k|      else {
  108|  43.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.5k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  43.5k|            else if constexpr( has_apply0_bool ) {
  153|  43.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.5k|            }
  155|  43.5k|         }
  156|  43.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.5k, False: 0]
  ------------------
  157|  43.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.5k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  43.5k|         (void)m( result );
  163|  43.5k|         return result;
  164|  43.5k|      }
  165|  43.5k|   }
_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|  43.5k|      {
   73|  43.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|  43.5k|         else {
   84|  43.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.5k|      }
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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  42.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.9k|      else {
  108|  42.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  42.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.2k, False: 696]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  42.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.2k|            }
  155|  42.2k|         }
  156|  42.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.2k, False: 696]
  ------------------
  157|  42.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.2k|         }
  159|    696|         else {
  160|    696|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    696|         }
  162|  42.9k|         (void)m( result );
  163|  42.9k|         return result;
  164|  42.9k|      }
  165|  42.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  42.9k|      {
   73|  42.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.9k|         else {
   84|  42.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  42.9k|      {
   59|  42.9k|         return Rule::match( in );
   60|  42.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    696|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    696|      else {
  108|    696|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    696|         using iterator_t = typename ParseInput::iterator_t;
  111|    696|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    696|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    696|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    696|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    696|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    696|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    696|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    696|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    696|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    696|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    696|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    696|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    696|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    696|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    696|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    696|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    696|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    696|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 638, False: 58]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    638|            else if constexpr( has_apply0_bool ) {
  153|    638|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    638|            }
  155|    638|         }
  156|    696|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 638, False: 58]
  ------------------
  157|    638|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    638|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|    696|         (void)m( result );
  163|    696|         return result;
  164|    696|      }
  165|    696|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    696|      {
   73|    696|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    696|         else {
   84|    696|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    696|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    696|      }
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|    696|      {
   59|    696|         return Rule::match( in );
   60|    696|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.14M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.14M|      else {
  108|  9.14M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.14M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.14M|         constexpr bool has_apply_void = enable_action && internal::has_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.14M|         constexpr bool has_apply_bool = enable_action && internal::has_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.14M|         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.14M|         constexpr bool has_apply0_void = enable_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.14M|         constexpr bool has_apply0_bool = enable_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.14M|         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.14M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.14M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.14M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.14M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.14M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.14M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.14M|         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.14M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.14M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.14M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.14M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.14M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.14M, False: 201]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.14M|            else if constexpr( has_apply0_bool ) {
  153|  9.14M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.14M|            }
  155|  9.14M|         }
  156|  9.14M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.14M, False: 201]
  ------------------
  157|  9.14M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.14M|         }
  159|    201|         else {
  160|    201|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    201|         }
  162|  9.14M|         (void)m( result );
  163|  9.14M|         return result;
  164|  9.14M|      }
  165|  9.14M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.14M|      {
   73|  9.14M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.14M|         else {
   84|  9.14M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.14M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.14M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.14M|      {
   59|  9.14M|         return Rule::match( in );
   60|  9.14M|      }
_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|  30.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.5k|      else {
  108|  30.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  30.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 27.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|  2.58k|            else if constexpr( has_apply0_bool ) {
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  30.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 27.9k]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|  27.9k|         else {
  160|  27.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.9k|         }
  162|  30.5k|         (void)m( result );
  163|  30.5k|         return result;
  164|  30.5k|      }
  165|  30.5k|   }
_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|  30.5k|      {
   73|  30.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.5k|         else {
   84|  30.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_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|  30.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.5k|      else {
  108|  30.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  30.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 27.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|  2.58k|            else if constexpr( has_apply0_bool ) {
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  30.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 27.9k]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|  27.9k|         else {
  160|  27.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.9k|         }
  162|  30.5k|         (void)m( result );
  163|  30.5k|         return result;
  164|  30.5k|      }
  165|  30.5k|   }
_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|  30.5k|      {
   73|  30.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.5k|         else {
   84|  30.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_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|  30.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.5k|      else {
  108|  30.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  30.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 30.5k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 30.5k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.23k, False: 27.3k]
  ------------------
  143|  3.23k|            if constexpr( has_apply_void ) {
  144|  3.23k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.23k|         }
  156|  30.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.22k, False: 27.3k]
  ------------------
  157|  3.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.22k|         }
  159|  27.3k|         else {
  160|  27.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.3k|         }
  162|  30.5k|         (void)m( result );
  163|  30.5k|         return result;
  164|  30.5k|      }
  165|  30.5k|   }
_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|  30.5k|      {
   73|  30.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.5k|         else {
   84|  30.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.5k|      {
   59|  30.5k|         return Rule::match( in );
   60|  30.5k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  10.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.0k|      else {
  108|  10.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.62k, False: 1.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.62k|            else if constexpr( has_apply0_bool ) {
  153|  8.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.62k|            }
  155|  8.62k|         }
  156|  10.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.62k, False: 1.40k]
  ------------------
  157|  8.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.62k|         }
  159|  1.40k|         else {
  160|  1.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.40k|         }
  162|  10.0k|         (void)m( result );
  163|  10.0k|         return result;
  164|  10.0k|      }
  165|  10.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.0k|      {
   73|  10.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.0k|         else {
   84|  10.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.0k|      {
   44|  10.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.0k|      else {
  108|  10.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  10.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.62k, False: 1.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.62k|            else if constexpr( has_apply0_bool ) {
  153|  8.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.62k|            }
  155|  8.62k|         }
  156|  10.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.62k, False: 1.40k]
  ------------------
  157|  8.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.62k|         }
  159|  1.40k|         else {
  160|  1.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.40k|         }
  162|  10.0k|         (void)m( result );
  163|  10.0k|         return result;
  164|  10.0k|      }
  165|  10.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.0k|      {
   73|  10.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.0k|         else {
   84|  10.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.0k|      {
   59|  10.0k|         return Rule::match( in );
   60|  10.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.8k|      else {
  108|  16.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.96k, 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.96k|            else if constexpr( has_apply0_bool ) {
  153|  3.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.96k|            }
  155|  3.96k|         }
  156|  16.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.96k, False: 12.8k]
  ------------------
  157|  3.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.96k|         }
  159|  12.8k|         else {
  160|  12.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.8k|         }
  162|  16.8k|         (void)m( result );
  163|  16.8k|         return result;
  164|  16.8k|      }
  165|  16.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|  16.8k|      {
   73|  16.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|  16.8k|         else {
   84|  16.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.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|  16.8k|      {
   59|  16.8k|         return Rule::match( in );
   60|  16.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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.58k, False: 628]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.58k|            else if constexpr( has_apply0_bool ) {
  153|  2.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.58k|            }
  155|  2.58k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.58k, False: 628]
  ------------------
  157|  2.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.58k|         }
  159|    628|         else {
  160|    628|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    628|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.97k, False: 1.24k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.97k|            else if constexpr( has_apply0_bool ) {
  153|  1.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.97k|            }
  155|  1.97k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.97k, False: 1.24k]
  ------------------
  157|  1.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.97k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 0]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|  3.21k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.21k|         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.21k|   }
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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.21k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.21k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.27k, False: 1.94k]
  ------------------
  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.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.27k, False: 1.94k]
  ------------------
  157|  1.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.27k|         }
  159|  1.94k|         else {
  160|  1.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.94k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 204, 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|    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.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 3.01k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.21k|      {
   59|  3.21k|         return Rule::match( in );
   60|  3.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.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: 220, False: 2.79k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.01k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 2.79k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  2.79k|         else {
  160|  2.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.79k|         }
  162|  3.01k|         (void)m( result );
  163|  3.01k|         return result;
  164|  3.01k|      }
  165|  3.01k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.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_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.01k|      {
   59|  3.01k|         return Rule::match( in );
   60|  3.01k|      }
_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.79k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.79k|      else {
  108|  2.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.79k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.79k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.79k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.79k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.79k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.79k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.79k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.79k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 2.59k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    197|            else if constexpr( has_apply0_bool ) {
  153|    197|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    197|            }
  155|    197|         }
  156|  2.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.59k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.59k|         else {
  160|  2.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.59k|         }
  162|  2.79k|         (void)m( result );
  163|  2.79k|         return result;
  164|  2.79k|      }
  165|  2.79k|   }
_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.79k|      {
   73|  2.79k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.79k|         else {
   84|  2.79k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.79k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.79k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.79k|      {
   59|  2.79k|         return Rule::match( in );
   60|  2.79k|      }
_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.59k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.59k|      else {
  108|  2.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.40k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.40k|         else {
  160|  2.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.40k|         }
  162|  2.59k|         (void)m( result );
  163|  2.59k|         return result;
  164|  2.59k|      }
  165|  2.59k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.59k|      {
   73|  2.59k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.59k|         else {
   84|  2.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.59k|      {
   59|  2.59k|         return Rule::match( in );
   60|  2.59k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.40k|      else {
  108|  2.40k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.40k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.40k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.40k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.40k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.40k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.40k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.40k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.40k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.40k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.40k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.40k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.40k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.40k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.40k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.40k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 257, False: 2.14k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    257|            else if constexpr( has_apply0_bool ) {
  153|    257|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    257|            }
  155|    257|         }
  156|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 257, False: 2.14k]
  ------------------
  157|    257|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    257|         }
  159|  2.14k|         else {
  160|  2.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.14k|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_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.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_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.40k|      {
   59|  2.40k|         return Rule::match( in );
   60|  2.40k|      }
_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.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: 202, False: 1.94k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  2.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 1.94k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  1.94k|         else {
  160|  1.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.94k|         }
  162|  2.14k|         (void)m( result );
  163|  2.14k|         return result;
  164|  2.14k|      }
  165|  2.14k|   }
_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.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_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.14k|      {
   59|  2.14k|         return Rule::match( in );
   60|  2.14k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.17k, False: 1.04k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 1.04k]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|  1.04k|         else {
  160|  1.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.04k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   59|  3.21k|         return Rule::match( in );
   60|  3.21k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.26k|      else {
  108|  4.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.26k, 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.26k|            else if constexpr( has_apply0_bool ) {
  153|  4.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.26k|            }
  155|  4.26k|         }
  156|  4.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.26k, False: 0]
  ------------------
  157|  4.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.26k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.26k|         (void)m( result );
  163|  4.26k|         return result;
  164|  4.26k|      }
  165|  4.26k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.26k|      {
   73|  4.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.26k|         else {
   84|  4.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.26k|      {
   44|  4.26k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.26k|      }
_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.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.17k|      else {
  108|  2.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.09k, 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.09k|            else if constexpr( has_apply0_bool ) {
  153|  2.09k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.09k|            }
  155|  2.09k|         }
  156|  2.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.09k, False: 79]
  ------------------
  157|  2.09k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.09k|         }
  159|     79|         else {
  160|     79|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     79|         }
  162|  2.17k|         (void)m( result );
  163|  2.17k|         return result;
  164|  2.17k|      }
  165|  2.17k|   }
_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.17k|      {
   73|  2.17k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.17k|         else {
   84|  2.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.17k|      {
   44|  2.17k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.17k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.11k|   {
  104|  2.11k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.11k|         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.11k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.11k|      {
   44|  2.11k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.11k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.52k|   {
  104|  5.52k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.52k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.52k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.52k|      {
   44|  5.52k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.52k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.09k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.09k|      else {
  108|  2.09k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.09k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.09k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.09k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.09k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.09k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.09k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.09k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.09k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.09k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.09k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.09k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.09k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.09k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.09k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.09k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.09k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.09k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.09k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.09k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.97k, False: 124]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.97k|            else if constexpr( has_apply0_bool ) {
  153|  1.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.97k|            }
  155|  1.97k|         }
  156|  2.09k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.97k, False: 124]
  ------------------
  157|  1.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.97k|         }
  159|    124|         else {
  160|    124|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    124|         }
  162|  2.09k|         (void)m( result );
  163|  2.09k|         return result;
  164|  2.09k|      }
  165|  2.09k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.09k|      {
   73|  2.09k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.09k|         else {
   84|  2.09k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.09k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.09k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.09k|      {
   59|  2.09k|         return Rule::match( in );
   60|  2.09k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.55k|      else {
  108|  7.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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): [True: 0, Folded]
  ------------------
  112|  7.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|  7.55k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.55k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.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|  7.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|  7.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|  7.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.55k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.19k, False: 1.35k]
  ------------------
  143|  6.19k|            if constexpr( has_apply_void ) {
  144|  6.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  6.19k|         }
  156|  7.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.14k, False: 1.41k]
  ------------------
  157|  6.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.14k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  7.55k|         (void)m( result );
  163|  7.55k|         return result;
  164|  7.55k|      }
  165|  7.55k|   }
_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|  7.55k|      {
   73|  7.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|  7.55k|         else {
   84|  7.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.55k|      }
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|  7.55k|      {
   44|  7.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.55k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.55k|      else {
  108|  7.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.45k, 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|  6.45k|            else if constexpr( has_apply0_bool ) {
  153|  6.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.45k|            }
  155|  6.45k|         }
  156|  7.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.45k, False: 1.10k]
  ------------------
  157|  6.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.45k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|  7.55k|         (void)m( result );
  163|  7.55k|         return result;
  164|  7.55k|      }
  165|  7.55k|   }
_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|  7.55k|      {
   73|  7.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|  7.55k|         else {
   84|  7.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.55k|      }
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|  7.55k|      {
   59|  7.55k|         return Rule::match( in );
   60|  7.55k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.45k|   {
  104|  6.45k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.45k|         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.45k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.45k|      {
   44|  6.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.45k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.45k|      else {
  108|  6.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.19k, 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|  6.19k|            else if constexpr( has_apply0_bool ) {
  153|  6.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.19k|            }
  155|  6.19k|         }
  156|  6.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.19k, False: 256]
  ------------------
  157|  6.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.19k|         }
  159|    256|         else {
  160|    256|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    256|         }
  162|  6.45k|         (void)m( result );
  163|  6.45k|         return result;
  164|  6.45k|      }
  165|  6.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.45k|      {
   73|  6.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.45k|         else {
   84|  6.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.45k|      {
   44|  6.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.45k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.83M|      else {
  108|  7.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.19k, False: 7.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|  6.19k|            else if constexpr( has_apply0_bool ) {
  153|  6.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.19k|            }
  155|  6.19k|         }
  156|  7.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.19k, False: 7.83M]
  ------------------
  157|  6.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.19k|         }
  159|  7.83M|         else {
  160|  7.83M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.83M|         }
  162|  7.83M|         (void)m( result );
  163|  7.83M|         return result;
  164|  7.83M|      }
  165|  7.83M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.83M|      {
   73|  7.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|  7.83M|         else {
   84|  7.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.83M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.83M|      {
   59|  7.83M|         return Rule::match( in );
   60|  7.83M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.83M|      else {
  108|  7.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.83M, 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.83M|            else if constexpr( has_apply0_bool ) {
  153|  7.83M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.83M|            }
  155|  7.83M|         }
  156|  7.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.83M, False: 256]
  ------------------
  157|  7.83M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.83M|         }
  159|    256|         else {
  160|    256|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    256|         }
  162|  7.83M|         (void)m( result );
  163|  7.83M|         return result;
  164|  7.83M|      }
  165|  7.83M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.83M|      {
   73|  7.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|  7.83M|         else {
   84|  7.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.83M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.83M|      {
   44|  7.83M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.83M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.83M|      else {
  108|  7.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 161k, False: 7.67M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   161k|            else if constexpr( has_apply0_bool ) {
  153|   161k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   161k|            }
  155|   161k|         }
  156|  7.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 161k, False: 7.67M]
  ------------------
  157|   161k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   161k|         }
  159|  7.67M|         else {
  160|  7.67M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.67M|         }
  162|  7.83M|         (void)m( result );
  163|  7.83M|         return result;
  164|  7.83M|      }
  165|  7.83M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.83M|      {
   73|  7.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|  7.83M|         else {
   84|  7.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.83M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.83M|      {
   44|  7.83M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.83M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.83M|      else {
  108|  7.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 161k, False: 7.67M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   161k|            else if constexpr( has_apply0_bool ) {
  153|   161k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   161k|            }
  155|   161k|         }
  156|  7.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 161k, False: 7.67M]
  ------------------
  157|   161k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   161k|         }
  159|  7.67M|         else {
  160|  7.67M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.67M|         }
  162|  7.83M|         (void)m( result );
  163|  7.83M|         return result;
  164|  7.83M|      }
  165|  7.83M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.83M|      {
   73|  7.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|  7.83M|         else {
   84|  7.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.83M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.83M|      {
   59|  7.83M|         return Rule::match( in );
   60|  7.83M|      }
_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|   161k|   {
  104|   161k|      if constexpr( !Control< Rule >::enable ) {
  105|   161k|         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|   161k|   }
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|   161k|      {
   44|   161k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   161k|      }
_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|   161k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   161k|      else {
  108|   161k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   161k|         using iterator_t = typename ParseInput::iterator_t;
  111|   161k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   161k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   161k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   161k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   161k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   161k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   161k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   161k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   161k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   161k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   161k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   161k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   161k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   161k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   161k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   161k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   161k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   161k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 161k, False: 92]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   161k|            else if constexpr( has_apply0_bool ) {
  153|   161k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   161k|            }
  155|   161k|         }
  156|   161k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 161k, False: 92]
  ------------------
  157|   161k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   161k|         }
  159|     92|         else {
  160|     92|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     92|         }
  162|   161k|         (void)m( result );
  163|   161k|         return result;
  164|   161k|      }
  165|   161k|   }
_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|   161k|      {
   73|   161k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   161k|         else {
   84|   161k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   161k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   161k|      }
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|   161k|      {
   44|   161k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   161k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   161k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   161k|      else {
  108|   161k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   161k|         using iterator_t = typename ParseInput::iterator_t;
  111|   161k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   161k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   161k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   161k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   161k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   161k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   161k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   161k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   161k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   161k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   161k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   161k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   161k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   161k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   161k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   161k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   161k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   161k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 74.6k, False: 86.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|  74.6k|            else if constexpr( has_apply0_bool ) {
  153|  74.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  74.6k|            }
  155|  74.6k|         }
  156|   161k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 74.6k, False: 86.9k]
  ------------------
  157|  74.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  74.6k|         }
  159|  86.9k|         else {
  160|  86.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.9k|         }
  162|   161k|         (void)m( result );
  163|   161k|         return result;
  164|   161k|      }
  165|   161k|   }
_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|   161k|      {
   73|   161k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   161k|         else {
   84|   161k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   161k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   161k|      }
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|   161k|      {
   44|   161k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   161k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   161k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   161k|      else {
  108|   161k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   161k|         using iterator_t = typename ParseInput::iterator_t;
  111|   161k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   161k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   161k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   161k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   161k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   161k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   161k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   161k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   161k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   161k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   161k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   161k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   161k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   161k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   161k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   161k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   161k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   161k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 74.6k, False: 86.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|  74.6k|            else if constexpr( has_apply0_bool ) {
  153|  74.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  74.6k|            }
  155|  74.6k|         }
  156|   161k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 74.6k, False: 86.9k]
  ------------------
  157|  74.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  74.6k|         }
  159|  86.9k|         else {
  160|  86.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  86.9k|         }
  162|   161k|         (void)m( result );
  163|   161k|         return result;
  164|   161k|      }
  165|   161k|   }
_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|   161k|      {
   73|   161k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   161k|         else {
   84|   161k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   161k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   161k|      }
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|   161k|      {
   59|   161k|         return Rule::match( in );
   60|   161k|      }
_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|  74.6k|   {
  104|  74.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  74.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|  74.6k|   }
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|  74.6k|      {
   44|  74.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  74.6k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  74.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  74.6k|      else {
  108|  74.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  74.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  74.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|  74.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|  74.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|  74.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|  74.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|  74.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|  74.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  74.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  74.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  74.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|  74.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  74.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  74.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|  74.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  74.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  74.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  74.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  74.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 74.6k, False: 37]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  74.6k|            else if constexpr( has_apply0_bool ) {
  153|  74.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  74.6k|            }
  155|  74.6k|         }
  156|  74.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 74.6k, False: 37]
  ------------------
  157|  74.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  74.6k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|  74.6k|         (void)m( result );
  163|  74.6k|         return result;
  164|  74.6k|      }
  165|  74.6k|   }
_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|  74.6k|      {
   73|  74.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|  74.6k|         else {
   84|  74.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  74.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  74.6k|      }
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|  74.6k|      {
   44|  74.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  74.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   149k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   149k|      else {
  108|   149k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   149k|         using iterator_t = typename ParseInput::iterator_t;
  111|   149k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   149k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   149k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   149k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   149k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   149k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   149k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   149k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   149k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   149k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   149k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   149k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   149k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   149k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   149k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   149k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   149k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   149k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 149k, False: 37]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   149k|            else if constexpr( has_apply0_bool ) {
  153|   149k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   149k|            }
  155|   149k|         }
  156|   149k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 149k, False: 37]
  ------------------
  157|   149k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   149k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|   149k|         (void)m( result );
  163|   149k|         return result;
  164|   149k|      }
  165|   149k|   }
_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|   149k|      {
   73|   149k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   149k|         else {
   84|   149k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   149k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   149k|      }
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|   149k|      {
   59|   149k|         return Rule::match( in );
   60|   149k|      }
_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.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  86.9k|      else {
  108|  86.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  86.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  86.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|  86.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|  86.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|  86.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|  86.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|  86.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|  86.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  86.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  86.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  86.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|  86.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  86.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  86.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|  86.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  86.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  86.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  86.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  86.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.0k, False: 60.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|  26.0k|            else if constexpr( has_apply0_bool ) {
  153|  26.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.0k|            }
  155|  26.0k|         }
  156|  86.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.0k, False: 60.9k]
  ------------------
  157|  26.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.0k|         }
  159|  60.9k|         else {
  160|  60.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  60.9k|         }
  162|  86.9k|         (void)m( result );
  163|  86.9k|         return result;
  164|  86.9k|      }
  165|  86.9k|   }
_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.9k|      {
   73|  86.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|  86.9k|         else {
   84|  86.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  86.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  86.9k|      }
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.9k|      {
   44|  86.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  86.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   121k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   121k|      else {
  108|   121k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   121k|         using iterator_t = typename ParseInput::iterator_t;
  111|   121k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   121k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   121k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   121k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   121k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   121k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   121k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   121k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   121k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   121k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   121k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   121k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   121k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   121k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   121k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   121k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   121k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   121k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.4k, False: 80.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|  41.4k|            else if constexpr( has_apply0_bool ) {
  153|  41.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.4k|            }
  155|  41.4k|         }
  156|   121k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.4k, False: 80.1k]
  ------------------
  157|  41.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.4k|         }
  159|  80.1k|         else {
  160|  80.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  80.1k|         }
  162|   121k|         (void)m( result );
  163|   121k|         return result;
  164|   121k|      }
  165|   121k|   }
_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|   121k|      {
   73|   121k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   121k|         else {
   84|   121k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   121k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   121k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   121k|      {
   59|   121k|         return Rule::match( in );
   60|   121k|      }
_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|  26.0k|   {
  104|  26.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  26.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|  26.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  26.0k|      {
   44|  26.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.0k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  26.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.0k|      else {
  108|  26.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.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|  26.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|  26.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|  26.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|  26.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.0k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  26.0k|            else if constexpr( has_apply0_bool ) {
  153|  26.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.0k|            }
  155|  26.0k|         }
  156|  26.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.0k, False: 0]
  ------------------
  157|  26.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  26.0k|         (void)m( result );
  163|  26.0k|         return result;
  164|  26.0k|      }
  165|  26.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  26.0k|      {
   73|  26.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|  26.0k|         else {
   84|  26.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  26.0k|      {
   44|  26.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  60.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  60.9k|      else {
  108|  60.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  60.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  60.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|  60.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|  60.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|  60.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|  60.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|  60.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|  60.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  60.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  60.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  60.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|  60.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  60.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  60.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|  60.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  60.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  60.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  60.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  60.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 58.6k, False: 2.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  60.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 58.6k, False: 2.25k]
  ------------------
  157|  58.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  58.6k|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|  60.9k|         (void)m( result );
  163|  60.9k|         return result;
  164|  60.9k|      }
  165|  60.9k|   }
_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|  60.9k|      {
   73|  60.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|  60.9k|         else {
   84|  60.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  60.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  60.9k|      }
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|  60.9k|      {
   59|  60.9k|         return Rule::match( in );
   60|  60.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.25k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.25k|      else {
  108|  2.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.25k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.19k, False: 55]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.19k|            else if constexpr( has_apply0_bool ) {
  153|  2.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.19k|            }
  155|  2.19k|         }
  156|  2.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.19k, False: 55]
  ------------------
  157|  2.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.19k|         }
  159|     55|         else {
  160|     55|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     55|         }
  162|  2.25k|         (void)m( result );
  163|  2.25k|         return result;
  164|  2.25k|      }
  165|  2.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.25k|      {
   73|  2.25k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.25k|         else {
   84|  2.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.25k|      {
   59|  2.25k|         return Rule::match( in );
   60|  2.25k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.67M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.67M|      else {
  108|  7.67M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.67M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.67M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.67M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.67M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.67M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.67M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.67M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.67M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.67M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.67M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.67M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.67M, False: 164]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.67M|            else if constexpr( has_apply0_bool ) {
  153|  7.67M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.67M|            }
  155|  7.67M|         }
  156|  7.67M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.67M, False: 164]
  ------------------
  157|  7.67M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.67M|         }
  159|    164|         else {
  160|    164|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    164|         }
  162|  7.67M|         (void)m( result );
  163|  7.67M|         return result;
  164|  7.67M|      }
  165|  7.67M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.67M|      {
   73|  7.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|  7.67M|         else {
   84|  7.67M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.67M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.67M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.67M|      {
   59|  7.67M|         return Rule::match( in );
   60|  7.67M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.6k|      else {
  108|  27.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 25.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.53k|            else if constexpr( has_apply0_bool ) {
  153|  2.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.53k|            }
  155|  2.53k|         }
  156|  27.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 25.1k]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|  25.1k|         else {
  160|  25.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.1k|         }
  162|  27.6k|         (void)m( result );
  163|  27.6k|         return result;
  164|  27.6k|      }
  165|  27.6k|   }
_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|  27.6k|      {
   73|  27.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|  27.6k|         else {
   84|  27.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.6k|      }
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|  27.6k|      {
   44|  27.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.6k|      }
_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|  27.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.6k|      else {
  108|  27.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 25.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.53k|            else if constexpr( has_apply0_bool ) {
  153|  2.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.53k|            }
  155|  2.53k|         }
  156|  27.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 25.1k]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|  25.1k|         else {
  160|  25.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.1k|         }
  162|  27.6k|         (void)m( result );
  163|  27.6k|         return result;
  164|  27.6k|      }
  165|  27.6k|   }
_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|  27.6k|      {
   73|  27.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|  27.6k|         else {
   84|  27.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.6k|      }
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|  27.6k|      {
   44|  27.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.6k|      else {
  108|  27.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 27.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  27.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|  27.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|  27.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|  27.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 27.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.01k, False: 24.6k]
  ------------------
  143|  3.01k|            if constexpr( has_apply_void ) {
  144|  3.01k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.01k|         }
  156|  27.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.00k, False: 24.6k]
  ------------------
  157|  3.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.00k|         }
  159|  24.6k|         else {
  160|  24.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.6k|         }
  162|  27.6k|         (void)m( result );
  163|  27.6k|         return result;
  164|  27.6k|      }
  165|  27.6k|   }
_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|  27.6k|      {
   73|  27.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|  27.6k|         else {
   84|  27.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.6k|      }
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|  27.6k|      {
   59|  27.6k|         return Rule::match( in );
   60|  27.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.39k|      else {
  108|  8.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.86k, False: 1.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.86k|            else if constexpr( has_apply0_bool ) {
  153|  6.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.86k|            }
  155|  6.86k|         }
  156|  8.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.86k, False: 1.53k]
  ------------------
  157|  6.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.86k|         }
  159|  1.53k|         else {
  160|  1.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.53k|         }
  162|  8.39k|         (void)m( result );
  163|  8.39k|         return result;
  164|  8.39k|      }
  165|  8.39k|   }
_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.39k|      {
   73|  8.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.39k|         else {
   84|  8.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.39k|      }
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.39k|      {
   44|  8.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.39k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.39k|      else {
  108|  8.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.86k, False: 1.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.86k|            else if constexpr( has_apply0_bool ) {
  153|  6.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.86k|            }
  155|  6.86k|         }
  156|  8.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.86k, False: 1.53k]
  ------------------
  157|  6.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.86k|         }
  159|  1.53k|         else {
  160|  1.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.53k|         }
  162|  8.39k|         (void)m( result );
  163|  8.39k|         return result;
  164|  8.39k|      }
  165|  8.39k|   }
_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.39k|      {
   73|  8.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.39k|         else {
   84|  8.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.39k|      }
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.39k|      {
   59|  8.39k|         return Rule::match( in );
   60|  8.39k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.0k|      else {
  108|  16.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 10.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|  5.37k|            else if constexpr( has_apply0_bool ) {
  153|  5.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.37k|            }
  155|  5.37k|         }
  156|  16.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 10.6k]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|  10.6k|         else {
  160|  10.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.6k|         }
  162|  16.0k|         (void)m( result );
  163|  16.0k|         return result;
  164|  16.0k|      }
  165|  16.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  16.0k|      {
   73|  16.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|  16.0k|         else {
   84|  16.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.0k|      {
   59|  16.0k|         return Rule::match( in );
   60|  16.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 462]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.53k|            else if constexpr( has_apply0_bool ) {
  153|  2.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.53k|            }
  155|  2.53k|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 462]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|    462|         else {
  160|    462|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    462|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.99k|      {
   44|  2.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.99k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.77k, 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|  1.77k|            else if constexpr( has_apply0_bool ) {
  153|  1.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.77k|            }
  155|  1.77k|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.77k, False: 1.22k]
  ------------------
  157|  1.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.77k|         }
  159|  1.22k|         else {
  160|  1.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.22k|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.99k|      {
   44|  2.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.99k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.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|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 0]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.99k|      {
   44|  2.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.99k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|  2.99k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.99k|         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.99k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.99k|      {
   44|  2.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.99k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 2.99k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 2.99k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.60k, False: 1.39k]
  ------------------
  143|  1.60k|            if constexpr( has_apply_void ) {
  144|  1.60k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.60k|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.60k, False: 1.39k]
  ------------------
  157|  1.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.60k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.99k|      {
   44|  2.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.99k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 218, False: 2.77k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    218|            else if constexpr( has_apply0_bool ) {
  153|    218|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    218|            }
  155|    218|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 218, False: 2.77k]
  ------------------
  157|    218|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    218|         }
  159|  2.77k|         else {
  160|  2.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.77k|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.99k|      {
   59|  2.99k|         return Rule::match( in );
   60|  2.99k|      }
_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.77k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.77k|      else {
  108|  2.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.77k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.77k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.77k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.77k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.77k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.77k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.77k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.77k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 207, False: 2.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|    207|            else if constexpr( has_apply0_bool ) {
  153|    207|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    207|            }
  155|    207|         }
  156|  2.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 207, False: 2.56k]
  ------------------
  157|    207|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    207|         }
  159|  2.56k|         else {
  160|  2.56k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.56k|         }
  162|  2.77k|         (void)m( result );
  163|  2.77k|         return result;
  164|  2.77k|      }
  165|  2.77k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.77k|      {
   73|  2.77k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.77k|         else {
   84|  2.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.77k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.77k|      {
   59|  2.77k|         return Rule::match( in );
   60|  2.77k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.56k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.56k|      else {
  108|  2.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.56k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.56k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.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|    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.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.37k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.37k|         else {
  160|  2.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.37k|         }
  162|  2.56k|         (void)m( result );
  163|  2.56k|         return result;
  164|  2.56k|      }
  165|  2.56k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.56k|      {
   73|  2.56k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.56k|         else {
   84|  2.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.56k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.56k|      {
   59|  2.56k|         return Rule::match( in );
   60|  2.56k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.37k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.37k|      else {
  108|  2.37k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.37k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.37k|         constexpr bool has_apply_void = enable_action && internal::has_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.37k|         constexpr bool has_apply_bool = enable_action && internal::has_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.37k|         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.37k|         constexpr bool has_apply0_void = enable_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.37k|         constexpr bool has_apply0_bool = enable_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.37k|         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.37k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.37k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.37k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.37k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.37k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.37k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.37k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.37k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.37k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.37k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.37k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.37k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 66, False: 2.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|     66|            else if constexpr( has_apply0_bool ) {
  153|     66|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     66|            }
  155|     66|         }
  156|  2.37k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 66, False: 2.30k]
  ------------------
  157|     66|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     66|         }
  159|  2.30k|         else {
  160|  2.30k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.30k|         }
  162|  2.37k|         (void)m( result );
  163|  2.37k|         return result;
  164|  2.37k|      }
  165|  2.37k|   }
_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.37k|      {
   73|  2.37k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.37k|         else {
   84|  2.37k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.37k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.37k|      }
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.37k|      {
   59|  2.37k|         return Rule::match( in );
   60|  2.37k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.30k|      else {
  108|  2.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.30k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.30k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 332, 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|    332|            else if constexpr( has_apply0_bool ) {
  153|    332|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    332|            }
  155|    332|         }
  156|  2.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 1.97k]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  2.30k|         (void)m( result );
  163|  2.30k|         return result;
  164|  2.30k|      }
  165|  2.30k|   }
_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.30k|      {
   73|  2.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|  2.30k|         else {
   84|  2.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.30k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.30k|      {
   59|  2.30k|         return Rule::match( in );
   60|  2.30k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.97k|      else {
  108|  1.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 583, False: 1.39k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    583|            else if constexpr( has_apply0_bool ) {
  153|    583|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    583|            }
  155|    583|         }
  156|  1.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 583, False: 1.39k]
  ------------------
  157|    583|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    583|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  1.97k|         (void)m( result );
  163|  1.97k|         return result;
  164|  1.97k|      }
  165|  1.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.97k|      {
   73|  1.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|  1.97k|         else {
   84|  1.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.97k|      {
   59|  1.97k|         return Rule::match( in );
   60|  1.97k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.91k, False: 1.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.91k|            else if constexpr( has_apply0_bool ) {
  153|  1.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.91k|            }
  155|  1.91k|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 1.07k]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|  1.07k|         else {
  160|  1.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.07k|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.99k|      {
   59|  2.99k|         return Rule::match( in );
   60|  2.99k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.78k|      else {
  108|  3.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.78k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.78k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.78k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.78k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.78k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.78k|            else if constexpr( has_apply0_bool ) {
  153|  3.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.78k|            }
  155|  3.78k|         }
  156|  3.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.78k, False: 0]
  ------------------
  157|  3.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.78k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.78k|         (void)m( result );
  163|  3.78k|         return result;
  164|  3.78k|      }
  165|  3.78k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  3.78k|      {
   73|  3.78k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.78k|         else {
   84|  3.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.78k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.78k|      {
   44|  3.78k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.78k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  1.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91k|      else {
  108|  1.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.87k, False: 48]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.87k|            else if constexpr( has_apply0_bool ) {
  153|  1.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.87k|            }
  155|  1.87k|         }
  156|  1.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.87k, False: 48]
  ------------------
  157|  1.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.87k|         }
  159|     48|         else {
  160|     48|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     48|         }
  162|  1.91k|         (void)m( result );
  163|  1.91k|         return result;
  164|  1.91k|      }
  165|  1.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  1.91k|      {
   73|  1.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.91k|         else {
   84|  1.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.91k|      {
   44|  1.91k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.91k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.88k|   {
  104|  1.88k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.88k|         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.88k|   }
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.88k|      {
   44|  1.88k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.88k|      }
_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.78k|   {
  104|  3.78k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.78k|         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.78k|   }
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.78k|      {
   44|  3.78k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.78k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.87k|      else {
  108|  1.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.77k, False: 98]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.77k|            else if constexpr( has_apply0_bool ) {
  153|  1.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.77k|            }
  155|  1.77k|         }
  156|  1.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.77k, False: 98]
  ------------------
  157|  1.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.77k|         }
  159|     98|         else {
  160|     98|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     98|         }
  162|  1.87k|         (void)m( result );
  163|  1.87k|         return result;
  164|  1.87k|      }
  165|  1.87k|   }
_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.87k|      {
   73|  1.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|  1.87k|         else {
   84|  1.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.87k|      }
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.87k|      {
   59|  1.87k|         return Rule::match( in );
   60|  1.87k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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): [True: 0, Folded]
  ------------------
  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): [True: 5.42k, Folded]
  |  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): [True: 5.42k, Folded]
  |  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: 4.56k, False: 869]
  ------------------
  143|  4.56k|            if constexpr( has_apply_void ) {
  144|  4.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|  4.56k|         }
  156|  5.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.54k, False: 882]
  ------------------
  157|  4.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.54k|         }
  159|    882|         else {
  160|    882|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    882|         }
  162|  5.42k|         (void)m( result );
  163|  5.42k|         return result;
  164|  5.42k|      }
  165|  5.42k|   }
_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.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_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.42k|      {
   44|  5.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.42k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_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: 4.77k, False: 655]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.77k|            else if constexpr( has_apply0_bool ) {
  153|  4.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.77k|            }
  155|  4.77k|         }
  156|  5.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.77k, False: 655]
  ------------------
  157|  4.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.77k|         }
  159|    655|         else {
  160|    655|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    655|         }
  162|  5.42k|         (void)m( result );
  163|  5.42k|         return result;
  164|  5.42k|      }
  165|  5.42k|   }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser14serial_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|      }
_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.77k|   {
  104|  4.77k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.77k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.77k|   }
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.77k|      {
   44|  4.77k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.77k|      }
_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.77k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.77k|      else {
  108|  4.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.77k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.77k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.77k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.77k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.77k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.77k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.77k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.77k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.56k, False: 214]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.56k|            else if constexpr( has_apply0_bool ) {
  153|  4.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.56k|            }
  155|  4.56k|         }
  156|  4.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.56k, False: 214]
  ------------------
  157|  4.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.56k|         }
  159|    214|         else {
  160|    214|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    214|         }
  162|  4.77k|         (void)m( result );
  163|  4.77k|         return result;
  164|  4.77k|      }
  165|  4.77k|   }
_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.77k|      {
   73|  4.77k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.77k|         else {
   84|  4.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.77k|      }
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.77k|      {
   44|  4.77k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.77k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.46M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.46M|      else {
  108|  2.46M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.46M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.46M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.46M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.46M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.46M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.46M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.46M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.46M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.46M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.46M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.46M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.56k, False: 2.45M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.56k|            else if constexpr( has_apply0_bool ) {
  153|  4.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.56k|            }
  155|  4.56k|         }
  156|  2.46M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.56k, False: 2.45M]
  ------------------
  157|  4.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.56k|         }
  159|  2.45M|         else {
  160|  2.45M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45M|         }
  162|  2.46M|         (void)m( result );
  163|  2.46M|         return result;
  164|  2.46M|      }
  165|  2.46M|   }
_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.46M|      {
   73|  2.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|  2.46M|         else {
   84|  2.46M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.46M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.46M|      }
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.46M|      {
   59|  2.46M|         return Rule::match( in );
   60|  2.46M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.45M|      else {
  108|  2.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45M|         constexpr bool has_apply_void = enable_action && internal::has_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.45M|         constexpr bool has_apply_bool = enable_action && internal::has_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.45M|         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.45M|         constexpr bool has_apply0_void = enable_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.45M|         constexpr bool has_apply0_bool = enable_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.45M|         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.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.45M, False: 214]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45M|            else if constexpr( has_apply0_bool ) {
  153|  2.45M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.45M|            }
  155|  2.45M|         }
  156|  2.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.45M, False: 214]
  ------------------
  157|  2.45M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.45M|         }
  159|    214|         else {
  160|    214|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    214|         }
  162|  2.45M|         (void)m( result );
  163|  2.45M|         return result;
  164|  2.45M|      }
  165|  2.45M|   }
_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.45M|      {
   73|  2.45M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.45M|         else {
   84|  2.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45M|      }
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.45M|      {
   44|  2.45M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.45M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.45M|      else {
  108|  2.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45M|         constexpr bool has_apply_void = enable_action && internal::has_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.45M|         constexpr bool has_apply_bool = enable_action && internal::has_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.45M|         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.45M|         constexpr bool has_apply0_void = enable_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.45M|         constexpr bool has_apply0_bool = enable_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.45M|         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.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.27k, False: 2.45M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.27k|            else if constexpr( has_apply0_bool ) {
  153|  5.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.27k|            }
  155|  5.27k|         }
  156|  2.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.27k, False: 2.45M]
  ------------------
  157|  5.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.27k|         }
  159|  2.45M|         else {
  160|  2.45M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45M|         }
  162|  2.45M|         (void)m( result );
  163|  2.45M|         return result;
  164|  2.45M|      }
  165|  2.45M|   }
_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.45M|      {
   73|  2.45M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.45M|         else {
   84|  2.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45M|      }
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.45M|      {
   44|  2.45M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.45M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.45M|      else {
  108|  2.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45M|         constexpr bool has_apply_void = enable_action && internal::has_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.45M|         constexpr bool has_apply_bool = enable_action && internal::has_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.45M|         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.45M|         constexpr bool has_apply0_void = enable_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.45M|         constexpr bool has_apply0_bool = enable_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.45M|         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.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.33k, False: 2.45M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.33k|            else if constexpr( has_apply0_bool ) {
  153|  5.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.33k|            }
  155|  5.33k|         }
  156|  2.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.33k, False: 2.45M]
  ------------------
  157|  5.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.33k|         }
  159|  2.45M|         else {
  160|  2.45M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45M|         }
  162|  2.45M|         (void)m( result );
  163|  2.45M|         return result;
  164|  2.45M|      }
  165|  2.45M|   }
_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.45M|      {
   73|  2.45M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.45M|         else {
   84|  2.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45M|      }
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.45M|      {
   59|  2.45M|         return Rule::match( in );
   60|  2.45M|      }
_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|  5.33k|   {
  104|  5.33k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.33k|   }
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|  5.33k|      {
   44|  5.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.33k|      }
_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|  5.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.33k|      else {
  108|  5.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.27k, 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|  5.27k|            else if constexpr( has_apply0_bool ) {
  153|  5.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.27k|            }
  155|  5.27k|         }
  156|  5.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.27k, False: 52]
  ------------------
  157|  5.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.27k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  5.33k|         (void)m( result );
  163|  5.33k|         return result;
  164|  5.33k|      }
  165|  5.33k|   }
_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|  5.33k|      {
   73|  5.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|  5.33k|         else {
   84|  5.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.33k|      }
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|  5.33k|      {
   44|  5.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.33k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.33k|      else {
  108|  5.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.49k, False: 3.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|  1.49k|            else if constexpr( has_apply0_bool ) {
  153|  1.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.49k|            }
  155|  1.49k|         }
  156|  5.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.49k, False: 3.83k]
  ------------------
  157|  1.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.49k|         }
  159|  3.83k|         else {
  160|  3.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.83k|         }
  162|  5.33k|         (void)m( result );
  163|  5.33k|         return result;
  164|  5.33k|      }
  165|  5.33k|   }
_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|  5.33k|      {
   73|  5.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|  5.33k|         else {
   84|  5.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.33k|      }
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|  5.33k|      {
   44|  5.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.33k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.33k|      else {
  108|  5.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.52k, False: 3.80k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.52k|            else if constexpr( has_apply0_bool ) {
  153|  1.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.52k|            }
  155|  1.52k|         }
  156|  5.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.52k, False: 3.80k]
  ------------------
  157|  1.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.52k|         }
  159|  3.80k|         else {
  160|  3.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.80k|         }
  162|  5.33k|         (void)m( result );
  163|  5.33k|         return result;
  164|  5.33k|      }
  165|  5.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.33k|      {
   73|  5.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|  5.33k|         else {
   84|  5.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.33k|      }
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|  5.33k|      {
   59|  5.33k|         return Rule::match( in );
   60|  5.33k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  1.52k|   {
  104|  1.52k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.52k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.52k|   }
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|  1.52k|      {
   44|  1.52k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.52k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.52k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.52k|      else {
  108|  1.52k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.52k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.52k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.52k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.52k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.52k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.52k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.52k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.52k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.52k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.52k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.52k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.49k, False: 26]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.49k|            else if constexpr( has_apply0_bool ) {
  153|  1.49k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.49k|            }
  155|  1.49k|         }
  156|  1.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.49k, False: 26]
  ------------------
  157|  1.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.49k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  1.52k|         (void)m( result );
  163|  1.52k|         return result;
  164|  1.52k|      }
  165|  1.52k|   }
_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|  1.52k|      {
   73|  1.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|  1.52k|         else {
   84|  1.52k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.52k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.52k|      }
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|  1.52k|      {
   44|  1.52k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.52k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  3.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.00k, False: 26]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.00k|            else if constexpr( has_apply0_bool ) {
  153|  3.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.00k|            }
  155|  3.00k|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.00k, False: 26]
  ------------------
  157|  3.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.00k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  3.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.80k|      else {
  108|  3.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.80k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.80k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.80k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.80k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.80k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.80k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.80k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.80k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.04k, 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|  1.04k|            else if constexpr( has_apply0_bool ) {
  153|  1.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.04k|            }
  155|  1.04k|         }
  156|  3.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.04k, False: 2.76k]
  ------------------
  157|  1.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.04k|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  3.80k|         (void)m( result );
  163|  3.80k|         return result;
  164|  3.80k|      }
  165|  3.80k|   }
_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|  3.80k|      {
   73|  3.80k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.80k|         else {
   84|  3.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.80k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.80k|      {
   44|  3.80k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.80k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.26k|      else {
  108|  5.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.77k, 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|  1.77k|            else if constexpr( has_apply0_bool ) {
  153|  1.77k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.77k|            }
  155|  1.77k|         }
  156|  5.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.77k, False: 3.49k]
  ------------------
  157|  1.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.77k|         }
  159|  3.49k|         else {
  160|  3.49k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.49k|         }
  162|  5.26k|         (void)m( result );
  163|  5.26k|         return result;
  164|  5.26k|      }
  165|  5.26k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.26k|      {
   73|  5.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.26k|         else {
   84|  5.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.26k|      }
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|  5.26k|      {
   59|  5.26k|         return Rule::match( in );
   60|  5.26k|      }
_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.04k|   {
  104|  1.04k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.04k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.04k|   }
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.04k|      {
   44|  1.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.04k|      }
_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.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.04k|      else {
  108|  1.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.04k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.04k|            else if constexpr( has_apply0_bool ) {
  153|  1.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.04k|            }
  155|  1.04k|         }
  156|  1.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.04k, False: 0]
  ------------------
  157|  1.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.04k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  1.04k|         (void)m( result );
  163|  1.04k|         return result;
  164|  1.04k|      }
  165|  1.04k|   }
_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.04k|      {
   73|  1.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|  1.04k|         else {
   84|  1.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.04k|      }
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.04k|      {
   44|  1.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.76k|      else {
  108|  2.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 236]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.53k|            else if constexpr( has_apply0_bool ) {
  153|  2.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.53k|            }
  155|  2.53k|         }
  156|  2.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 236]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|    236|         else {
  160|    236|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    236|         }
  162|  2.76k|         (void)m( result );
  163|  2.76k|         return result;
  164|  2.76k|      }
  165|  2.76k|   }
_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|  2.76k|      {
   73|  2.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.76k|         else {
   84|  2.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  2.76k|      {
   59|  2.76k|         return Rule::match( in );
   60|  2.76k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    236|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    236|      else {
  108|    236|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    236|         using iterator_t = typename ParseInput::iterator_t;
  111|    236|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    236|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    236|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    236|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    236|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    236|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    236|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    236|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    236|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    236|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    236|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    236|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    236|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    236|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    236|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    236|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    236|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    236|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 210, False: 26]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    210|            else if constexpr( has_apply0_bool ) {
  153|    210|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    210|            }
  155|    210|         }
  156|    236|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 210, False: 26]
  ------------------
  157|    210|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    210|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|    236|         (void)m( result );
  163|    236|         return result;
  164|    236|      }
  165|    236|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    236|      {
   73|    236|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    236|         else {
   84|    236|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    236|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    236|      }
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|    236|      {
   59|    236|         return Rule::match( in );
   60|    236|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.45M|      else {
  108|  2.45M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45M|         constexpr bool has_apply_void = enable_action && internal::has_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.45M|         constexpr bool has_apply_bool = enable_action && internal::has_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.45M|         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.45M|         constexpr bool has_apply0_void = enable_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.45M|         constexpr bool has_apply0_bool = enable_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.45M|         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.45M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.45M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.45M, False: 162]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45M|            else if constexpr( has_apply0_bool ) {
  153|  2.45M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.45M|            }
  155|  2.45M|         }
  156|  2.45M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.45M, False: 162]
  ------------------
  157|  2.45M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.45M|         }
  159|    162|         else {
  160|    162|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    162|         }
  162|  2.45M|         (void)m( result );
  163|  2.45M|         return result;
  164|  2.45M|      }
  165|  2.45M|   }
_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.45M|      {
   73|  2.45M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.45M|         else {
   84|  2.45M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45M|      }
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.45M|      {
   59|  2.45M|         return Rule::match( in );
   60|  2.45M|      }
_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|  24.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.9k|      else {
  108|  24.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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|  24.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|  24.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|  24.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|  24.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|  24.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|  24.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 22.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.54k|            else if constexpr( has_apply0_bool ) {
  153|  2.54k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.54k|            }
  155|  2.54k|         }
  156|  24.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 22.3k]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|  22.3k|         else {
  160|  22.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.3k|         }
  162|  24.9k|         (void)m( result );
  163|  24.9k|         return result;
  164|  24.9k|      }
  165|  24.9k|   }
_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|  24.9k|      {
   73|  24.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|  24.9k|         else {
   84|  24.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.9k|      }
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|  24.9k|      {
   44|  24.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.9k|      }
_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|  24.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.9k|      else {
  108|  24.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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|  24.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|  24.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|  24.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|  24.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|  24.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|  24.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 22.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.54k|            else if constexpr( has_apply0_bool ) {
  153|  2.54k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.54k|            }
  155|  2.54k|         }
  156|  24.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 22.3k]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|  22.3k|         else {
  160|  22.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.3k|         }
  162|  24.9k|         (void)m( result );
  163|  24.9k|         return result;
  164|  24.9k|      }
  165|  24.9k|   }
_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|  24.9k|      {
   73|  24.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|  24.9k|         else {
   84|  24.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.9k|      }
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|  24.9k|      {
   44|  24.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.9k|      }
_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|  24.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.9k|      else {
  108|  24.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  24.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|  24.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 24.9k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  24.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|  24.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|  24.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|  24.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 24.9k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.23k, False: 21.6k]
  ------------------
  143|  3.23k|            if constexpr( has_apply_void ) {
  144|  3.23k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.23k|         }
  156|  24.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.22k, False: 21.6k]
  ------------------
  157|  3.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.22k|         }
  159|  21.6k|         else {
  160|  21.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.6k|         }
  162|  24.9k|         (void)m( result );
  163|  24.9k|         return result;
  164|  24.9k|      }
  165|  24.9k|   }
_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|  24.9k|      {
   73|  24.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|  24.9k|         else {
   84|  24.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.9k|      }
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|  24.9k|      {
   59|  24.9k|         return Rule::match( in );
   60|  24.9k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.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.46k, False: 1.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.46k|            else if constexpr( has_apply0_bool ) {
  153|  7.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.46k|            }
  155|  7.46k|         }
  156|  8.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.46k, False: 1.43k]
  ------------------
  157|  7.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.46k|         }
  159|  1.43k|         else {
  160|  1.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.43k|         }
  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_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_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_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.89k|      {
   44|  8.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_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.46k, False: 1.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.46k|            else if constexpr( has_apply0_bool ) {
  153|  7.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.46k|            }
  155|  7.46k|         }
  156|  8.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.46k, False: 1.43k]
  ------------------
  157|  7.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.46k|         }
  159|  1.43k|         else {
  160|  1.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.43k|         }
  162|  8.89k|         (void)m( result );
  163|  8.89k|         return result;
  164|  8.89k|      }
  165|  8.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  8.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_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_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_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  17.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.0k|      else {
  108|  17.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.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|  17.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|  17.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|  17.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|  17.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|  17.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|  17.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.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|  17.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.36k, False: 11.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|  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|  17.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.36k, False: 11.6k]
  ------------------
  157|  5.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.36k|         }
  159|  11.6k|         else {
  160|  11.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.6k|         }
  162|  17.0k|         (void)m( result );
  163|  17.0k|         return result;
  164|  17.0k|      }
  165|  17.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  17.0k|      {
   73|  17.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|  17.0k|         else {
   84|  17.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  17.0k|      {
   59|  17.0k|         return Rule::match( in );
   60|  17.0k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 664]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.54k|            else if constexpr( has_apply0_bool ) {
  153|  2.54k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.54k|            }
  155|  2.54k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 664]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|    664|         else {
  160|    664|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    664|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 1.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|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 1.28k]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|  1.28k|         else {
  160|  1.28k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.28k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.21k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.21k, False: 0]
  ------------------
  157|  3.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.21k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|  3.21k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.21k|         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.21k|   }
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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.21k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.21k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.22k, False: 1.98k]
  ------------------
  143|  1.22k|            if constexpr( has_apply_void ) {
  144|  1.22k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.22k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.22k, False: 1.98k]
  ------------------
  157|  1.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.22k|         }
  159|  1.98k|         else {
  160|  1.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.98k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   44|  3.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.21k|      }
_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.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 82, False: 3.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|     82|            else if constexpr( has_apply0_bool ) {
  153|     82|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     82|            }
  155|     82|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 82, False: 3.13k]
  ------------------
  157|     82|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     82|         }
  159|  3.13k|         else {
  160|  3.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.13k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.21k|      {
   59|  3.21k|         return Rule::match( in );
   60|  3.21k|      }
_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.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.13k|      else {
  108|  3.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.13k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.13k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.13k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.13k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.13k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.13k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 223, False: 2.90k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    223|            else if constexpr( has_apply0_bool ) {
  153|    223|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    223|            }
  155|    223|         }
  156|  3.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 223, False: 2.90k]
  ------------------
  157|    223|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    223|         }
  159|  2.90k|         else {
  160|  2.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.90k|         }
  162|  3.13k|         (void)m( result );
  163|  3.13k|         return result;
  164|  3.13k|      }
  165|  3.13k|   }
_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.13k|      {
   73|  3.13k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.13k|         else {
   84|  3.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.13k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.13k|      {
   59|  3.13k|         return Rule::match( in );
   60|  3.13k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.90k|      else {
  108|  2.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.90k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 261, 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|    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.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 261, False: 2.64k]
  ------------------
  157|    261|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    261|         }
  159|  2.64k|         else {
  160|  2.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.64k|         }
  162|  2.90k|         (void)m( result );
  163|  2.90k|         return result;
  164|  2.90k|      }
  165|  2.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.90k|      {
   73|  2.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.90k|         else {
   84|  2.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.90k|      {
   59|  2.90k|         return Rule::match( in );
   60|  2.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.64k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.64k|      else {
  108|  2.64k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.64k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.64k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.64k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.64k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.64k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.64k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.64k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.64k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.64k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.64k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.64k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.64k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.64k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.64k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.64k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.64k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.64k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.64k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.64k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.45k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.64k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.45k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.45k|         else {
  160|  2.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.45k|         }
  162|  2.64k|         (void)m( result );
  163|  2.64k|         return result;
  164|  2.64k|      }
  165|  2.64k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.64k|      {
   73|  2.64k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.64k|         else {
   84|  2.64k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.64k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.64k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.64k|      {
   59|  2.64k|         return Rule::match( in );
   60|  2.64k|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.45k|      else {
  108|  2.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 270, False: 2.18k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 270, False: 2.18k]
  ------------------
  157|    270|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    270|         }
  159|  2.18k|         else {
  160|  2.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.18k|         }
  162|  2.45k|         (void)m( result );
  163|  2.45k|         return result;
  164|  2.45k|      }
  165|  2.45k|   }
_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.45k|      {
   73|  2.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.45k|         else {
   84|  2.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.45k|      {
   59|  2.45k|         return Rule::match( in );
   60|  2.45k|      }
_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.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.18k|      else {
  108|  2.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.18k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.18k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 1.98k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    197|            else if constexpr( has_apply0_bool ) {
  153|    197|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    197|            }
  155|    197|         }
  156|  2.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 1.98k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  1.98k|         else {
  160|  1.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.98k|         }
  162|  2.18k|         (void)m( result );
  163|  2.18k|         return result;
  164|  2.18k|      }
  165|  2.18k|   }
_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.18k|      {
   73|  2.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|  2.18k|         else {
   84|  2.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.18k|      {
   59|  2.18k|         return Rule::match( in );
   60|  2.18k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.12k, False: 1.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|  2.12k|            else if constexpr( has_apply0_bool ) {
  153|  2.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.12k|            }
  155|  2.12k|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.12k, False: 1.08k]
  ------------------
  157|  2.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.12k|         }
  159|  1.08k|         else {
  160|  1.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.08k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_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.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.21k|      {
   59|  3.21k|         return Rule::match( in );
   60|  3.21k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.18k|      {
   44|  4.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.18k|      }
_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.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.12k|      else {
  108|  2.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.12k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.05k, False: 71]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.05k|            else if constexpr( has_apply0_bool ) {
  153|  2.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.05k|            }
  155|  2.05k|         }
  156|  2.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.05k, False: 71]
  ------------------
  157|  2.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.05k|         }
  159|     71|         else {
  160|     71|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     71|         }
  162|  2.12k|         (void)m( result );
  163|  2.12k|         return result;
  164|  2.12k|      }
  165|  2.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.12k|      {
   73|  2.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.12k|         else {
   84|  2.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_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.12k|      {
   44|  2.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.12k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.06k|   {
  104|  2.06k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.06k|         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.06k|   }
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.06k|      {
   44|  2.06k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.06k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.44k|   {
  104|  4.44k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.44k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.44k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.44k|      {
   44|  4.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.44k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.05k|      else {
  108|  2.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.05k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.05k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.05k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.05k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.05k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.05k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 129]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  2.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 129]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|    129|         else {
  160|    129|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    129|         }
  162|  2.05k|         (void)m( result );
  163|  2.05k|         return result;
  164|  2.05k|      }
  165|  2.05k|   }
_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.05k|      {
   73|  2.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.05k|         else {
   84|  2.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.05k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.05k|      {
   59|  2.05k|         return Rule::match( in );
   60|  2.05k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.45k|      else {
  108|  6.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.45k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.45k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, False: 1.35k]
  ------------------
  143|  5.10k|            if constexpr( has_apply_void ) {
  144|  5.10k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.10k|         }
  156|  6.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.06k, False: 1.39k]
  ------------------
  157|  5.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.06k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  6.45k|         (void)m( result );
  163|  6.45k|         return result;
  164|  6.45k|      }
  165|  6.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.45k|      {
   73|  6.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.45k|         else {
   84|  6.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.45k|      {
   44|  6.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.45k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.45k|      else {
  108|  6.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.39k, False: 1.06k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.39k|            else if constexpr( has_apply0_bool ) {
  153|  5.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.39k|            }
  155|  5.39k|         }
  156|  6.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.39k, False: 1.06k]
  ------------------
  157|  5.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.39k|         }
  159|  1.06k|         else {
  160|  1.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.06k|         }
  162|  6.45k|         (void)m( result );
  163|  6.45k|         return result;
  164|  6.45k|      }
  165|  6.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.45k|      {
   73|  6.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.45k|         else {
   84|  6.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.45k|      {
   59|  6.45k|         return Rule::match( in );
   60|  6.45k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.39k|   {
  104|  5.39k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.39k|         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.39k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.39k|      {
   44|  5.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.39k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.39k|      else {
  108|  5.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, 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|  5.10k|            else if constexpr( has_apply0_bool ) {
  153|  5.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.10k|            }
  155|  5.10k|         }
  156|  5.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.10k, False: 289]
  ------------------
  157|  5.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.10k|         }
  159|    289|         else {
  160|    289|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    289|         }
  162|  5.39k|         (void)m( result );
  163|  5.39k|         return result;
  164|  5.39k|      }
  165|  5.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.39k|      {
   73|  5.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.39k|         else {
   84|  5.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.39k|      {
   44|  5.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.39k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.50M|      else {
  108|  6.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, False: 6.50M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.10k|            else if constexpr( has_apply0_bool ) {
  153|  5.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.10k|            }
  155|  5.10k|         }
  156|  6.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.10k, False: 6.50M]
  ------------------
  157|  5.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.10k|         }
  159|  6.50M|         else {
  160|  6.50M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.50M|         }
  162|  6.50M|         (void)m( result );
  163|  6.50M|         return result;
  164|  6.50M|      }
  165|  6.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.50M|      {
   73|  6.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.50M|         else {
   84|  6.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.50M|      {
   59|  6.50M|         return Rule::match( in );
   60|  6.50M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.50M|      else {
  108|  6.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.50M, 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|  6.50M|            else if constexpr( has_apply0_bool ) {
  153|  6.50M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.50M|            }
  155|  6.50M|         }
  156|  6.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.50M, False: 289]
  ------------------
  157|  6.50M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.50M|         }
  159|    289|         else {
  160|    289|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    289|         }
  162|  6.50M|         (void)m( result );
  163|  6.50M|         return result;
  164|  6.50M|      }
  165|  6.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.50M|      {
   73|  6.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.50M|         else {
   84|  6.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.50M|      {
   44|  6.50M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.50M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.50M|      else {
  108|  6.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 69.7k, False: 6.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|  69.7k|            else if constexpr( has_apply0_bool ) {
  153|  69.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  69.7k|            }
  155|  69.7k|         }
  156|  6.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 69.7k, False: 6.43M]
  ------------------
  157|  69.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  69.7k|         }
  159|  6.43M|         else {
  160|  6.43M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.43M|         }
  162|  6.50M|         (void)m( result );
  163|  6.50M|         return result;
  164|  6.50M|      }
  165|  6.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.50M|      {
   73|  6.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.50M|         else {
   84|  6.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.50M|      {
   44|  6.50M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.50M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.50M|      else {
  108|  6.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.50M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 69.8k, False: 6.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|  69.8k|            else if constexpr( has_apply0_bool ) {
  153|  69.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  69.8k|            }
  155|  69.8k|         }
  156|  6.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 69.8k, False: 6.43M]
  ------------------
  157|  69.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  69.8k|         }
  159|  6.43M|         else {
  160|  6.43M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.43M|         }
  162|  6.50M|         (void)m( result );
  163|  6.50M|         return result;
  164|  6.50M|      }
  165|  6.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.50M|      {
   73|  6.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.50M|         else {
   84|  6.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.50M|      {
   59|  6.50M|         return Rule::match( in );
   60|  6.50M|      }
_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|  69.8k|   {
  104|  69.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  69.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  69.8k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  69.8k|      {
   44|  69.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  69.8k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  69.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  69.8k|      else {
  108|  69.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  69.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  69.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|  69.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|  69.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|  69.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|  69.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|  69.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|  69.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  69.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  69.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  69.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|  69.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  69.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  69.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|  69.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  69.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  69.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  69.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  69.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 69.7k, 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|  69.7k|            else if constexpr( has_apply0_bool ) {
  153|  69.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  69.7k|            }
  155|  69.7k|         }
  156|  69.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 69.7k, False: 84]
  ------------------
  157|  69.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  69.7k|         }
  159|     84|         else {
  160|     84|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     84|         }
  162|  69.8k|         (void)m( result );
  163|  69.8k|         return result;
  164|  69.8k|      }
  165|  69.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  69.8k|      {
   73|  69.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|  69.8k|         else {
   84|  69.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  69.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  69.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  69.8k|      {
   44|  69.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  69.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  69.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  69.8k|      else {
  108|  69.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  69.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  69.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|  69.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|  69.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|  69.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|  69.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|  69.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|  69.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  69.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  69.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  69.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|  69.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  69.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  69.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|  69.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  69.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  69.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  69.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  69.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.4k, False: 39.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|  30.4k|            else if constexpr( has_apply0_bool ) {
  153|  30.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.4k|            }
  155|  30.4k|         }
  156|  69.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.4k, False: 39.3k]
  ------------------
  157|  30.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.4k|         }
  159|  39.3k|         else {
  160|  39.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  39.3k|         }
  162|  69.8k|         (void)m( result );
  163|  69.8k|         return result;
  164|  69.8k|      }
  165|  69.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  69.8k|      {
   73|  69.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|  69.8k|         else {
   84|  69.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  69.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  69.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  69.8k|      {
   44|  69.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  69.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  69.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  69.8k|      else {
  108|  69.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  69.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  69.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|  69.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|  69.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|  69.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|  69.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|  69.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|  69.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  69.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  69.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  69.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|  69.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  69.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  69.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|  69.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  69.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  69.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  69.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  69.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.5k, False: 39.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|  30.5k|            else if constexpr( has_apply0_bool ) {
  153|  30.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.5k|            }
  155|  30.5k|         }
  156|  69.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.5k, False: 39.3k]
  ------------------
  157|  30.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.5k|         }
  159|  39.3k|         else {
  160|  39.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  39.3k|         }
  162|  69.8k|         (void)m( result );
  163|  69.8k|         return result;
  164|  69.8k|      }
  165|  69.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  69.8k|      {
   73|  69.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|  69.8k|         else {
   84|  69.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  69.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  69.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  69.8k|      {
   59|  69.8k|         return Rule::match( in );
   60|  69.8k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  30.5k|   {
  104|  30.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  30.5k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  30.5k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  30.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.5k|      else {
  108|  30.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  30.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.4k, False: 26]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  30.4k|            else if constexpr( has_apply0_bool ) {
  153|  30.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.4k|            }
  155|  30.4k|         }
  156|  30.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.4k, False: 26]
  ------------------
  157|  30.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.4k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  30.5k|         (void)m( result );
  163|  30.5k|         return result;
  164|  30.5k|      }
  165|  30.5k|   }
_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|  30.5k|      {
   73|  30.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.5k|         else {
   84|  30.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  61.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  61.0k|      else {
  108|  61.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  61.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  61.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|  61.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|  61.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|  61.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|  61.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|  61.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|  61.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  61.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  61.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  61.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|  61.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  61.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  61.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|  61.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  61.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  61.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  61.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  61.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 60.9k, False: 26]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  60.9k|            else if constexpr( has_apply0_bool ) {
  153|  60.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  60.9k|            }
  155|  60.9k|         }
  156|  61.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 60.9k, False: 26]
  ------------------
  157|  60.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  60.9k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  61.0k|         (void)m( result );
  163|  61.0k|         return result;
  164|  61.0k|      }
  165|  61.0k|   }
_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|  61.0k|      {
   73|  61.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|  61.0k|         else {
   84|  61.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  61.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  61.0k|      }
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|  61.0k|      {
   59|  61.0k|         return Rule::match( in );
   60|  61.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  39.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.3k|      else {
  108|  39.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  39.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  39.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|  39.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|  39.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|  39.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|  39.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  39.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.9k, False: 24.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|  14.9k|            else if constexpr( has_apply0_bool ) {
  153|  14.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.9k|            }
  155|  14.9k|         }
  156|  39.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.9k, False: 24.4k]
  ------------------
  157|  14.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.9k|         }
  159|  24.4k|         else {
  160|  24.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.4k|         }
  162|  39.3k|         (void)m( result );
  163|  39.3k|         return result;
  164|  39.3k|      }
  165|  39.3k|   }
_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|  39.3k|      {
   73|  39.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|  39.3k|         else {
   84|  39.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  39.3k|      {
   44|  39.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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: 22.9k, False: 36.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|  22.9k|            else if constexpr( has_apply0_bool ) {
  153|  22.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.9k|            }
  155|  22.9k|         }
  156|  59.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.9k, False: 36.0k]
  ------------------
  157|  22.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.9k|         }
  159|  36.0k|         else {
  160|  36.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.0k|         }
  162|  59.0k|         (void)m( result );
  163|  59.0k|         return result;
  164|  59.0k|      }
  165|  59.0k|   }
_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|  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_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|  59.0k|      {
   59|  59.0k|         return Rule::match( in );
   60|  59.0k|      }
_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|  14.9k|   {
  104|  14.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  14.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  14.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  14.9k|      {
   44|  14.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.9k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  14.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.9k|      else {
  108|  14.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.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|  14.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|  14.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|  14.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|  14.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|  14.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|  14.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.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|  14.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.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|  14.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.9k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  14.9k|            else if constexpr( has_apply0_bool ) {
  153|  14.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.9k|            }
  155|  14.9k|         }
  156|  14.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.9k, False: 0]
  ------------------
  157|  14.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  14.9k|         (void)m( result );
  163|  14.9k|         return result;
  164|  14.9k|      }
  165|  14.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  14.9k|      {
   73|  14.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|  14.9k|         else {
   84|  14.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  14.9k|      {
   44|  14.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  24.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.4k|      else {
  108|  24.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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|  24.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|  24.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|  24.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|  24.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|  24.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|  24.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.9k, False: 437]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  23.9k|            else if constexpr( has_apply0_bool ) {
  153|  23.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.9k|            }
  155|  23.9k|         }
  156|  24.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.9k, False: 437]
  ------------------
  157|  23.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.9k|         }
  159|    437|         else {
  160|    437|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    437|         }
  162|  24.4k|         (void)m( result );
  163|  24.4k|         return result;
  164|  24.4k|      }
  165|  24.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|  24.4k|      {
   73|  24.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|  24.4k|         else {
   84|  24.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.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|  24.4k|      {
   59|  24.4k|         return Rule::match( in );
   60|  24.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    437|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    437|      else {
  108|    437|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    437|         using iterator_t = typename ParseInput::iterator_t;
  111|    437|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    437|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    437|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    437|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    437|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    437|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    437|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    437|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    437|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    437|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    437|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    437|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    437|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    437|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    437|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    437|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    437|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    437|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 379, False: 58]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|    437|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 379, False: 58]
  ------------------
  157|    379|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    379|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|    437|         (void)m( result );
  163|    437|         return result;
  164|    437|      }
  165|    437|   }
_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|    437|      {
   73|    437|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    437|         else {
   84|    437|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    437|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    437|      }
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|    437|      {
   59|    437|         return Rule::match( in );
   60|    437|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.43M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.43M|      else {
  108|  6.43M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.43M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.43M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.43M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.43M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.43M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.43M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.43M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.43M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.43M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.43M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.43M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.43M, False: 205]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43M|            else if constexpr( has_apply0_bool ) {
  153|  6.43M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.43M|            }
  155|  6.43M|         }
  156|  6.43M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.43M, False: 205]
  ------------------
  157|  6.43M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.43M|         }
  159|    205|         else {
  160|    205|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    205|         }
  162|  6.43M|         (void)m( result );
  163|  6.43M|         return result;
  164|  6.43M|      }
  165|  6.43M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.43M|      {
   73|  6.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|  6.43M|         else {
   84|  6.43M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.43M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.43M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.43M|      {
   59|  6.43M|         return Rule::match( in );
   60|  6.43M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, 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.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|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 19.0k]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|  19.0k|         else {
  160|  19.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.0k|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.0k|      {
   73|  22.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, 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.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|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 19.0k]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|  19.0k|         else {
  160|  19.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.0k|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.0k|      {
   73|  22.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  22.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 22.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 22.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.46k, False: 18.5k]
  ------------------
  143|  3.46k|            if constexpr( has_apply_void ) {
  144|  3.46k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.46k|         }
  156|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.46k, False: 18.5k]
  ------------------
  157|  3.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.46k|         }
  159|  18.5k|         else {
  160|  18.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.5k|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.0k|      {
   73|  22.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  22.0k|      {
   59|  22.0k|         return Rule::match( in );
   60|  22.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   168k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   168k|      else {
  108|   168k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   168k|         using iterator_t = typename ParseInput::iterator_t;
  111|   168k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   168k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   168k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   168k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   168k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   168k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   168k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   168k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   168k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   168k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   168k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   168k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   168k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   168k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   168k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   168k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   168k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   168k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 166k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   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|   168k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 166k, False: 1.87k]
  ------------------
  157|   166k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   166k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|   168k|         (void)m( result );
  163|   168k|         return result;
  164|   168k|      }
  165|   168k|   }
_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|   168k|      {
   73|   168k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   168k|         else {
   84|   168k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   168k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   168k|      }
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|   168k|      {
   44|   168k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   168k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   168k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   168k|      else {
  108|   168k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   168k|         using iterator_t = typename ParseInput::iterator_t;
  111|   168k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   168k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   168k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   168k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   168k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   168k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   168k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   168k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   168k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   168k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   168k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   168k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   168k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   168k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   168k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   168k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   168k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   168k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 166k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   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|   168k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 166k, False: 1.87k]
  ------------------
  157|   166k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   166k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|   168k|         (void)m( result );
  163|   168k|         return result;
  164|   168k|      }
  165|   168k|   }
_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|   168k|      {
   73|   168k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   168k|         else {
   84|   168k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   168k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   168k|      }
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|   168k|      {
   59|   168k|         return Rule::match( in );
   60|   168k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.62M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.62M|      else {
  108|  1.62M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.62M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.62M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.62M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.62M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.62M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.62M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.62M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.62M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.62M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.62M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.62M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.62M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.62M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.62M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.62M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.62M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.62M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.62M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.62M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.45M, False: 172k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45M|            else if constexpr( has_apply0_bool ) {
  153|  1.45M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.45M|            }
  155|  1.45M|         }
  156|  1.62M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.45M, False: 172k]
  ------------------
  157|  1.45M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.45M|         }
  159|   172k|         else {
  160|   172k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   172k|         }
  162|  1.62M|         (void)m( result );
  163|  1.62M|         return result;
  164|  1.62M|      }
  165|  1.62M|   }
_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.62M|      {
   73|  1.62M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.62M|         else {
   84|  1.62M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.62M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.62M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.62M|      {
   59|  1.62M|         return Rule::match( in );
   60|  1.62M|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, False: 462]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 462]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|    462|         else {
  160|    462|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    462|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.36k, 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.36k|            else if constexpr( has_apply0_bool ) {
  153|  2.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.36k|            }
  155|  2.36k|         }
  156|  3.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.36k, False: 1.09k]
  ------------------
  157|  2.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.36k|         }
  159|  1.09k|         else {
  160|  1.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.09k|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, 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.45k|            else if constexpr( has_apply0_bool ) {
  153|  3.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.45k|            }
  155|  3.45k|         }
  156|  3.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.45k, False: 0]
  ------------------
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_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.45k|   {
  104|  3.45k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.45k|         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.45k|   }
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.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.45k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.45k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.05k, False: 1.40k]
  ------------------
  143|  2.05k|            if constexpr( has_apply_void ) {
  144|  2.05k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.05k|         }
  156|  3.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.05k, False: 1.40k]
  ------------------
  157|  2.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.05k|         }
  159|  1.40k|         else {
  160|  1.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.40k|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   44|  3.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.45k|      }
_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.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 253, False: 3.20k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    253|            else if constexpr( has_apply0_bool ) {
  153|    253|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    253|            }
  155|    253|         }
  156|  3.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 253, False: 3.20k]
  ------------------
  157|    253|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    253|         }
  159|  3.20k|         else {
  160|  3.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.20k|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   59|  3.45k|         return Rule::match( in );
   60|  3.45k|      }
_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.20k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.20k|      else {
  108|  3.20k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.20k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.20k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.20k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.20k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.20k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.20k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.20k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.20k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.20k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.20k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.20k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.20k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.20k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.20k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.20k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.20k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.20k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.20k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.20k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 2.99k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 2.99k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  2.99k|         else {
  160|  2.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.99k|         }
  162|  3.20k|         (void)m( result );
  163|  3.20k|         return result;
  164|  3.20k|      }
  165|  3.20k|   }
_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.20k|      {
   73|  3.20k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.20k|         else {
   84|  3.20k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.20k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.20k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.20k|      {
   59|  3.20k|         return Rule::match( in );
   60|  3.20k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.99k|      else {
  108|  2.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.99k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.99k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.99k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.99k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 334, False: 2.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    334|            else if constexpr( has_apply0_bool ) {
  153|    334|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    334|            }
  155|    334|         }
  156|  2.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 334, False: 2.65k]
  ------------------
  157|    334|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    334|         }
  159|  2.65k|         else {
  160|  2.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.65k|         }
  162|  2.99k|         (void)m( result );
  163|  2.99k|         return result;
  164|  2.99k|      }
  165|  2.99k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.99k|      {
   73|  2.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.99k|         else {
   84|  2.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.99k|      {
   59|  2.99k|         return Rule::match( in );
   60|  2.99k|      }
_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.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.65k|      else {
  108|  2.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 293, False: 2.36k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    293|            else if constexpr( has_apply0_bool ) {
  153|    293|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    293|            }
  155|    293|         }
  156|  2.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 293, False: 2.36k]
  ------------------
  157|    293|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    293|         }
  159|  2.36k|         else {
  160|  2.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.36k|         }
  162|  2.65k|         (void)m( result );
  163|  2.65k|         return result;
  164|  2.65k|      }
  165|  2.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.65k|      {
   73|  2.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.65k|         else {
   84|  2.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.65k|      {
   59|  2.65k|         return Rule::match( in );
   60|  2.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.36k|      else {
  108|  2.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.36k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.36k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.36k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.36k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.36k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.36k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.36k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.36k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 493, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    493|            else if constexpr( has_apply0_bool ) {
  153|    493|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    493|            }
  155|    493|         }
  156|  2.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 493, False: 1.87k]
  ------------------
  157|    493|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    493|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|  2.36k|         (void)m( result );
  163|  2.36k|         return result;
  164|  2.36k|      }
  165|  2.36k|   }
_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.36k|      {
   73|  2.36k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.36k|         else {
   84|  2.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.36k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.36k|      {
   59|  2.36k|         return Rule::match( in );
   60|  2.36k|      }
_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.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.87k|      else {
  108|  1.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 467, False: 1.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    467|            else if constexpr( has_apply0_bool ) {
  153|    467|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    467|            }
  155|    467|         }
  156|  1.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 467, False: 1.40k]
  ------------------
  157|    467|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    467|         }
  159|  1.40k|         else {
  160|  1.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.40k|         }
  162|  1.87k|         (void)m( result );
  163|  1.87k|         return result;
  164|  1.87k|      }
  165|  1.87k|   }
_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.87k|      {
   73|  1.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|  1.87k|         else {
   84|  1.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.87k|      }
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.87k|      {
   59|  1.87k|         return Rule::match( in );
   60|  1.87k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.45k|      else {
  108|  3.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.45k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.60k, False: 853]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.60k, False: 853]
  ------------------
  157|  2.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.60k|         }
  159|    853|         else {
  160|    853|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    853|         }
  162|  3.45k|         (void)m( result );
  163|  3.45k|         return result;
  164|  3.45k|      }
  165|  3.45k|   }
_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.45k|      {
   73|  3.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.45k|         else {
   84|  3.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.45k|      }
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.45k|      {
   59|  3.45k|         return Rule::match( in );
   60|  3.45k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.15k|      else {
  108|  5.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.15k, 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.15k|            else if constexpr( has_apply0_bool ) {
  153|  5.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.15k|            }
  155|  5.15k|         }
  156|  5.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.15k, False: 0]
  ------------------
  157|  5.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.15k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.15k|         (void)m( result );
  163|  5.15k|         return result;
  164|  5.15k|      }
  165|  5.15k|   }
_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|  5.15k|      {
   73|  5.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.15k|         else {
   84|  5.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  5.15k|      {
   44|  5.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.15k|      }
_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.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.55k, 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|  2.55k|            else if constexpr( has_apply0_bool ) {
  153|  2.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.55k|            }
  155|  2.55k|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.55k, False: 52]
  ------------------
  157|  2.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.55k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  2.60k|         (void)m( result );
  163|  2.60k|         return result;
  164|  2.60k|      }
  165|  2.60k|   }
_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.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_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.60k|      {
   44|  2.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.60k|      }
_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.55k|   {
  104|  2.55k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.55k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.55k|   }
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.55k|      {
   44|  2.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.55k|      }
_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|   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_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|   163k|      {
   44|   163k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   163k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 2.36k, False: 189]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.36k|            else if constexpr( has_apply0_bool ) {
  153|  2.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.36k|            }
  155|  2.36k|         }
  156|  2.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.36k, False: 189]
  ------------------
  157|  2.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.36k|         }
  159|    189|         else {
  160|    189|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    189|         }
  162|  2.55k|         (void)m( result );
  163|  2.55k|         return result;
  164|  2.55k|      }
  165|  2.55k|   }
_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.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_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.55k|      {
   59|  2.55k|         return Rule::match( in );
   60|  2.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 165k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 165k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 163k, False: 1.22k]
  ------------------
  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|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 163k, False: 1.23k]
  ------------------
  157|   163k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   163k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_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|   165k|      {
   73|   165k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   165k|         else {
   84|   165k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   165k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   165k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   165k|      else {
  108|   165k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   165k|         using iterator_t = typename ParseInput::iterator_t;
  111|   165k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   165k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   165k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   165k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   165k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   165k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   165k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   165k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   165k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   165k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   165k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   165k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   165k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   165k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   165k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   165k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   165k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   165k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 164k, False: 1.12k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   164k|            else if constexpr( has_apply0_bool ) {
  153|   164k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   164k|            }
  155|   164k|         }
  156|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 164k, False: 1.12k]
  ------------------
  157|   164k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   164k|         }
  159|  1.12k|         else {
  160|  1.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.12k|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_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|   165k|      {
   73|   165k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   165k|         else {
   84|   165k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   165k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   165k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   826k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   826k|      else {
  108|   826k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   826k|         using iterator_t = typename ParseInput::iterator_t;
  111|   826k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   826k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   826k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   826k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   826k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   826k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   826k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   826k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   826k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   826k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   826k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   826k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   826k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   826k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   826k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   826k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   826k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   826k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 666k, False: 160k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   666k|            else if constexpr( has_apply0_bool ) {
  153|   666k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   666k|            }
  155|   666k|         }
  156|   826k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 666k, False: 160k]
  ------------------
  157|   666k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   666k|         }
  159|   160k|         else {
  160|   160k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   160k|         }
  162|   826k|         (void)m( result );
  163|   826k|         return result;
  164|   826k|      }
  165|   826k|   }
_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|   826k|      {
   73|   826k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   826k|         else {
   84|   826k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   826k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   826k|      }
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|   826k|      {
   59|   826k|         return Rule::match( in );
   60|   826k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   328k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   328k|      else {
  108|   328k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   328k|         using iterator_t = typename ParseInput::iterator_t;
  111|   328k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   328k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   328k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   328k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   328k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   328k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   328k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   328k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   328k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   328k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   328k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   328k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   328k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   328k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   328k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   328k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   328k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   328k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 327k, 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|   327k|            else if constexpr( has_apply0_bool ) {
  153|   327k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   327k|            }
  155|   327k|         }
  156|   328k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 327k, False: 60]
  ------------------
  157|   327k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   327k|         }
  159|     60|         else {
  160|     60|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     60|         }
  162|   328k|         (void)m( result );
  163|   328k|         return result;
  164|   328k|      }
  165|   328k|   }
_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|   328k|      {
   73|   328k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   328k|         else {
   84|   328k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   328k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   328k|      }
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|   328k|      {
   59|   328k|         return Rule::match( in );
   60|   328k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   327k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   327k|      else {
  108|   327k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   327k|         using iterator_t = typename ParseInput::iterator_t;
  111|   327k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   327k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   327k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   327k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   327k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   327k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   327k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   327k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   327k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   327k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   327k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   327k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   327k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   327k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   327k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   327k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   327k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   327k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 327k, False: 49]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   327k|            else if constexpr( has_apply0_bool ) {
  153|   327k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   327k|            }
  155|   327k|         }
  156|   327k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 327k, False: 49]
  ------------------
  157|   327k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   327k|         }
  159|     49|         else {
  160|     49|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     49|         }
  162|   327k|         (void)m( result );
  163|   327k|         return result;
  164|   327k|      }
  165|   327k|   }
_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|   327k|      {
   73|   327k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   327k|         else {
   84|   327k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   327k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   327k|      }
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|   327k|      {
   44|   327k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   327k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   327k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   327k|      else {
  108|   327k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   327k|         using iterator_t = typename ParseInput::iterator_t;
  111|   327k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   327k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   327k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   327k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   327k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   327k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   327k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   327k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   327k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   327k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   327k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   327k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   327k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   327k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   327k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   327k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   327k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   327k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 169k, False: 158k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   169k|            else if constexpr( has_apply0_bool ) {
  153|   169k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   169k|            }
  155|   169k|         }
  156|   327k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 169k, False: 158k]
  ------------------
  157|   169k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   169k|         }
  159|   158k|         else {
  160|   158k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   158k|         }
  162|   327k|         (void)m( result );
  163|   327k|         return result;
  164|   327k|      }
  165|   327k|   }
_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|   327k|      {
   73|   327k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   327k|         else {
   84|   327k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   327k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   327k|      }
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|   327k|      {
   44|   327k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   327k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   158k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   158k|      else {
  108|   158k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   158k|         using iterator_t = typename ParseInput::iterator_t;
  111|   158k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   158k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   158k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   158k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   158k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   158k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   158k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   158k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   158k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   158k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   158k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   158k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   158k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   158k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   158k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   158k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   158k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   158k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 158k, False: 49]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   158k|            else if constexpr( has_apply0_bool ) {
  153|   158k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   158k|            }
  155|   158k|         }
  156|   158k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 158k, False: 49]
  ------------------
  157|   158k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   158k|         }
  159|     49|         else {
  160|     49|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     49|         }
  162|   158k|         (void)m( result );
  163|   158k|         return result;
  164|   158k|      }
  165|   158k|   }
_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|   158k|      {
   73|   158k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   158k|         else {
   84|   158k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   158k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   158k|      }
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|   158k|      {
   59|   158k|         return Rule::match( in );
   60|   158k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.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: 2.17k, False: 16.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|  2.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 16.8k]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|  16.8k|         else {
  160|  16.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.8k|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.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_controlIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.0k|      {
   44|  19.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.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: 2.17k, False: 16.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|  2.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 16.8k]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|  16.8k|         else {
  160|  16.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.8k|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.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_controlIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.0k|      {
   44|  19.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.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): [True: 0, Folded]
  ------------------
  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): [True: 19.0k, Folded]
  |  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): [True: 19.0k, Folded]
  |  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: 2.76k, False: 16.2k]
  ------------------
  143|  2.76k|            if constexpr( has_apply_void ) {
  144|  2.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.76k|         }
  156|  19.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.75k, False: 16.2k]
  ------------------
  157|  2.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.75k|         }
  159|  16.2k|         else {
  160|  16.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.2k|         }
  162|  19.0k|         (void)m( result );
  163|  19.0k|         return result;
  164|  19.0k|      }
  165|  19.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.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_controlIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  19.0k|      {
   59|  19.0k|         return Rule::match( in );
   60|  19.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.13k|      else {
  108|  8.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.13k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.13k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.13k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.13k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.13k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.13k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.59k, False: 1.54k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.59k|            else if constexpr( has_apply0_bool ) {
  153|  6.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.59k|            }
  155|  6.59k|         }
  156|  8.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.59k, False: 1.54k]
  ------------------
  157|  6.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.59k|         }
  159|  1.54k|         else {
  160|  1.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.54k|         }
  162|  8.13k|         (void)m( result );
  163|  8.13k|         return result;
  164|  8.13k|      }
  165|  8.13k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  8.13k|      {
   73|  8.13k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.13k|         else {
   84|  8.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.13k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.13k|      {
   44|  8.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.13k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.13k|      else {
  108|  8.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.13k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.13k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.13k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.13k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.13k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.13k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.59k, False: 1.54k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.59k|            else if constexpr( has_apply0_bool ) {
  153|  6.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.59k|            }
  155|  6.59k|         }
  156|  8.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.59k, False: 1.54k]
  ------------------
  157|  6.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.59k|         }
  159|  1.54k|         else {
  160|  1.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.54k|         }
  162|  8.13k|         (void)m( result );
  163|  8.13k|         return result;
  164|  8.13k|      }
  165|  8.13k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  8.13k|      {
   73|  8.13k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.13k|         else {
   84|  8.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.13k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.13k|      {
   59|  8.13k|         return Rule::match( in );
   60|  8.13k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.4k|      else {
  108|  16.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  16.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.79k, False: 10.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|  5.79k|            else if constexpr( has_apply0_bool ) {
  153|  5.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.79k|            }
  155|  5.79k|         }
  156|  16.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.79k, False: 10.6k]
  ------------------
  157|  5.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.79k|         }
  159|  10.6k|         else {
  160|  10.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.6k|         }
  162|  16.4k|         (void)m( result );
  163|  16.4k|         return result;
  164|  16.4k|      }
  165|  16.4k|   }
_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|  16.4k|      {
   73|  16.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.4k|         else {
   84|  16.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  16.4k|      {
   59|  16.4k|         return Rule::match( in );
   60|  16.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.74k|      else {
  108|  2.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.74k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.17k, False: 575]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 575]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|    575|         else {
  160|    575|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    575|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.74k|      {
   73|  2.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.74k|         else {
   84|  2.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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: 1.86k, False: 882]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.86k|            else if constexpr( has_apply0_bool ) {
  153|  1.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.86k|            }
  155|  1.86k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 882]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|    882|         else {
  160|    882|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    882|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.74k|      else {
  108|  2.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.74k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.74k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.74k|            else if constexpr( has_apply0_bool ) {
  153|  2.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.74k|            }
  155|  2.74k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.74k, False: 0]
  ------------------
  157|  2.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.74k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.74k|      {
   73|  2.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.74k|         else {
   84|  2.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|  2.74k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.74k|         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.74k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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): [True: 0, Folded]
  ------------------
  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): [True: 2.74k, Folded]
  |  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): [True: 2.74k, Folded]
  |  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: 1.24k, False: 1.50k]
  ------------------
  143|  1.24k|            if constexpr( has_apply_void ) {
  144|  1.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|  1.24k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.24k, False: 1.50k]
  ------------------
  157|  1.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.24k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.74k|      {
   44|  2.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.74k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.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: 204, False: 2.54k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 2.54k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  2.54k|         else {
  160|  2.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.54k|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.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_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.74k|      {
   59|  2.74k|         return Rule::match( in );
   60|  2.74k|      }
_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.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.54k|      else {
  108|  2.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 220, False: 2.32k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 2.32k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  2.32k|         else {
  160|  2.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.32k|         }
  162|  2.54k|         (void)m( result );
  163|  2.54k|         return result;
  164|  2.54k|      }
  165|  2.54k|   }
_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.54k|      {
   73|  2.54k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.54k|         else {
   84|  2.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.54k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.54k|      {
   59|  2.54k|         return Rule::match( in );
   60|  2.54k|      }
_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.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.32k|      else {
  108|  2.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.32k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.32k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.32k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.32k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.32k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.32k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.32k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.32k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, 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|    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.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.13k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.13k|         else {
  160|  2.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.13k|         }
  162|  2.32k|         (void)m( result );
  163|  2.32k|         return result;
  164|  2.32k|      }
  165|  2.32k|   }
_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.32k|      {
   73|  2.32k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.32k|         else {
   84|  2.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.32k|      }
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.32k|      {
   59|  2.32k|         return Rule::match( in );
   60|  2.32k|      }
_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.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.13k|      else {
  108|  2.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 227, False: 1.90k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    227|            else if constexpr( has_apply0_bool ) {
  153|    227|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    227|            }
  155|    227|         }
  156|  2.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 227, False: 1.90k]
  ------------------
  157|    227|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    227|         }
  159|  1.90k|         else {
  160|  1.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90k|         }
  162|  2.13k|         (void)m( result );
  163|  2.13k|         return result;
  164|  2.13k|      }
  165|  2.13k|   }
_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.13k|      {
   73|  2.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|  2.13k|         else {
   84|  2.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.13k|      }
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.13k|      {
   59|  2.13k|         return Rule::match( in );
   60|  2.13k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.90k|      else {
  108|  1.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.90k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 186, 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|    186|            else if constexpr( has_apply0_bool ) {
  153|    186|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    186|            }
  155|    186|         }
  156|  1.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 186, False: 1.71k]
  ------------------
  157|    186|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    186|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  1.90k|         (void)m( result );
  163|  1.90k|         return result;
  164|  1.90k|      }
  165|  1.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.90k|      {
   73|  1.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.90k|         else {
   84|  1.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.90k|      {
   59|  1.90k|         return Rule::match( in );
   60|  1.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.71k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.71k|      else {
  108|  1.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, 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|    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|  1.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 1.50k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  1.71k|         (void)m( result );
  163|  1.71k|         return result;
  164|  1.71k|      }
  165|  1.71k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.71k|      {
   73|  1.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|  1.71k|         else {
   84|  1.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.71k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.71k|      {
   59|  1.71k|         return Rule::match( in );
   60|  1.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.74k|      else {
  108|  2.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.74k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.05k, False: 693]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.05k|            else if constexpr( has_apply0_bool ) {
  153|  2.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.05k|            }
  155|  2.05k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.05k, False: 693]
  ------------------
  157|  2.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.05k|         }
  159|    693|         else {
  160|    693|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    693|         }
  162|  2.74k|         (void)m( result );
  163|  2.74k|         return result;
  164|  2.74k|      }
  165|  2.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.74k|      {
   73|  2.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.74k|         else {
   84|  2.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.74k|      {
   59|  2.74k|         return Rule::match( in );
   60|  2.74k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_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.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.05k|      else {
  108|  2.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.05k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.05k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.05k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.05k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.05k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.05k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.98k, False: 73]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.98k|            else if constexpr( has_apply0_bool ) {
  153|  1.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.98k|            }
  155|  1.98k|         }
  156|  2.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.98k, False: 73]
  ------------------
  157|  1.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.98k|         }
  159|     73|         else {
  160|     73|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     73|         }
  162|  2.05k|         (void)m( result );
  163|  2.05k|         return result;
  164|  2.05k|      }
  165|  2.05k|   }
_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.05k|      {
   73|  2.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.05k|         else {
   84|  2.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.05k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.05k|      {
   44|  2.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.05k|      }
_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|  1.99k|   {
  104|  1.99k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.99k|         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.99k|   }
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|  1.99k|      {
   44|  1.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.99k|      }
_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.13k|   {
  104|  4.13k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.13k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.13k|   }
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.13k|      {
   44|  4.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.13k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.98k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.98k|      else {
  108|  1.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.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|  1.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|  1.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|  1.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|  1.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.98k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 116]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.86k|            else if constexpr( has_apply0_bool ) {
  153|  1.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.86k|            }
  155|  1.86k|         }
  156|  1.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 116]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|    116|         else {
  160|    116|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    116|         }
  162|  1.98k|         (void)m( result );
  163|  1.98k|         return result;
  164|  1.98k|      }
  165|  1.98k|   }
_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|  1.98k|      {
   73|  1.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|  1.98k|         else {
   84|  1.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.98k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.98k|      {
   59|  1.98k|         return Rule::match( in );
   60|  1.98k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.54k|      else {
  108|  5.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  5.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.54k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.54k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.49k, False: 1.05k]
  ------------------
  143|  4.49k|            if constexpr( has_apply_void ) {
  144|  4.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.49k|         }
  156|  5.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.44k, False: 1.10k]
  ------------------
  157|  4.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.44k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|  5.54k|         (void)m( result );
  163|  5.54k|         return result;
  164|  5.54k|      }
  165|  5.54k|   }
_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.54k|      {
   73|  5.54k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.54k|         else {
   84|  5.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.54k|      }
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.54k|      {
   44|  5.54k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.54k|      }
_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.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.54k|      else {
  108|  5.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.73k, False: 812]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  5.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.73k, False: 812]
  ------------------
  157|  4.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.73k|         }
  159|    812|         else {
  160|    812|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    812|         }
  162|  5.54k|         (void)m( result );
  163|  5.54k|         return result;
  164|  5.54k|      }
  165|  5.54k|   }
_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.54k|      {
   73|  5.54k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.54k|         else {
   84|  5.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.54k|      }
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.54k|      {
   59|  5.54k|         return Rule::match( in );
   60|  5.54k|      }
_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|  4.73k|   {
  104|  4.73k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.73k|         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.73k|   }
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|  4.73k|      {
   44|  4.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.73k|      }
_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|  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.49k, False: 245]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.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.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.49k, False: 245]
  ------------------
  157|  4.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.49k|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  4.73k|         (void)m( result );
  163|  4.73k|         return result;
  164|  4.73k|      }
  165|  4.73k|   }
_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|  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_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|  4.73k|      {
   44|  4.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.73k|      }
_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.81M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.81M|      else {
  108|  7.81M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.81M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.81M|         constexpr bool has_apply_void = enable_action && internal::has_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.81M|         constexpr bool has_apply_bool = enable_action && internal::has_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.81M|         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.81M|         constexpr bool has_apply0_void = enable_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.81M|         constexpr bool has_apply0_bool = enable_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.81M|         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.81M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.81M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.81M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.81M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.81M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.81M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.81M|         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.81M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.81M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.81M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.81M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.81M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.49k, False: 7.80M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  7.81M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.49k, False: 7.80M]
  ------------------
  157|  4.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.49k|         }
  159|  7.80M|         else {
  160|  7.80M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.80M|         }
  162|  7.81M|         (void)m( result );
  163|  7.81M|         return result;
  164|  7.81M|      }
  165|  7.81M|   }
_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.81M|      {
   73|  7.81M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.81M|         else {
   84|  7.81M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.81M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.81M|      }
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.81M|      {
   59|  7.81M|         return Rule::match( in );
   60|  7.81M|      }
_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.80M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.80M|      else {
  108|  7.80M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.80M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.80M|         constexpr bool has_apply_void = enable_action && internal::has_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.80M|         constexpr bool has_apply_bool = enable_action && internal::has_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.80M|         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.80M|         constexpr bool has_apply0_void = enable_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.80M|         constexpr bool has_apply0_bool = enable_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.80M|         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.80M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.80M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.80M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.80M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.80M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.80M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.80M|         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.80M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.80M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.80M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.80M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.80M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.80M, False: 245]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.80M|            else if constexpr( has_apply0_bool ) {
  153|  7.80M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.80M|            }
  155|  7.80M|         }
  156|  7.80M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.80M, False: 245]
  ------------------
  157|  7.80M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.80M|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  7.80M|         (void)m( result );
  163|  7.80M|         return result;
  164|  7.80M|      }
  165|  7.80M|   }
_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.80M|      {
   73|  7.80M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.80M|         else {
   84|  7.80M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.80M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.80M|      }
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.80M|      {
   44|  7.80M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.80M|      }
_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.80M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.80M|      else {
  108|  7.80M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.80M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.80M|         constexpr bool has_apply_void = enable_action && internal::has_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.80M|         constexpr bool has_apply_bool = enable_action && internal::has_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.80M|         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.80M|         constexpr bool has_apply0_void = enable_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.80M|         constexpr bool has_apply0_bool = enable_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.80M|         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.80M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.80M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.80M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.80M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.80M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.80M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.80M|         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.80M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.80M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.80M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.80M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.80M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.1k, False: 7.71M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.1k|            else if constexpr( has_apply0_bool ) {
  153|  88.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.1k|            }
  155|  88.1k|         }
  156|  7.80M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.1k, False: 7.71M]
  ------------------
  157|  88.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.1k|         }
  159|  7.71M|         else {
  160|  7.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.71M|         }
  162|  7.80M|         (void)m( result );
  163|  7.80M|         return result;
  164|  7.80M|      }
  165|  7.80M|   }
_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.80M|      {
   73|  7.80M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.80M|         else {
   84|  7.80M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.80M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.80M|      }
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.80M|      {
   44|  7.80M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.80M|      }
_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.80M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.80M|      else {
  108|  7.80M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.80M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.80M|         constexpr bool has_apply_void = enable_action && internal::has_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.80M|         constexpr bool has_apply_bool = enable_action && internal::has_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.80M|         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.80M|         constexpr bool has_apply0_void = enable_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.80M|         constexpr bool has_apply0_bool = enable_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.80M|         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.80M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.80M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.80M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.80M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.80M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.80M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.80M|         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.80M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.80M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.80M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.80M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.80M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.2k, False: 7.71M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.2k|            else if constexpr( has_apply0_bool ) {
  153|  88.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.2k|            }
  155|  88.2k|         }
  156|  7.80M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.2k, False: 7.71M]
  ------------------
  157|  88.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.2k|         }
  159|  7.71M|         else {
  160|  7.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.71M|         }
  162|  7.80M|         (void)m( result );
  163|  7.80M|         return result;
  164|  7.80M|      }
  165|  7.80M|   }
_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.80M|      {
   73|  7.80M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.80M|         else {
   84|  7.80M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.80M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.80M|      }
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.80M|      {
   59|  7.80M|         return Rule::match( in );
   60|  7.80M|      }
_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|  88.2k|   {
  104|  88.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  88.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|  88.2k|   }
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|  88.2k|      {
   44|  88.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.2k|      }
_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|  88.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.2k|      else {
  108|  88.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.1k, False: 76]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.1k|            else if constexpr( has_apply0_bool ) {
  153|  88.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.1k|            }
  155|  88.1k|         }
  156|  88.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.1k, False: 76]
  ------------------
  157|  88.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.1k|         }
  159|     76|         else {
  160|     76|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     76|         }
  162|  88.2k|         (void)m( result );
  163|  88.2k|         return result;
  164|  88.2k|      }
  165|  88.2k|   }
_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|  88.2k|      {
   73|  88.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|  88.2k|         else {
   84|  88.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.2k|      }
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|  88.2k|      {
   44|  88.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.2k|      }
_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|  88.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.2k|      else {
  108|  88.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.7k, False: 67.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|  20.7k|            else if constexpr( has_apply0_bool ) {
  153|  20.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.7k|            }
  155|  20.7k|         }
  156|  88.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.7k, False: 67.5k]
  ------------------
  157|  20.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.7k|         }
  159|  67.5k|         else {
  160|  67.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.5k|         }
  162|  88.2k|         (void)m( result );
  163|  88.2k|         return result;
  164|  88.2k|      }
  165|  88.2k|   }
_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|  88.2k|      {
   73|  88.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|  88.2k|         else {
   84|  88.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.2k|      }
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|  88.2k|      {
   44|  88.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  88.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.2k|      else {
  108|  88.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.7k, False: 67.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|  20.7k|            else if constexpr( has_apply0_bool ) {
  153|  20.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.7k|            }
  155|  20.7k|         }
  156|  88.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.7k, False: 67.4k]
  ------------------
  157|  20.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.7k|         }
  159|  67.4k|         else {
  160|  67.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  67.4k|         }
  162|  88.2k|         (void)m( result );
  163|  88.2k|         return result;
  164|  88.2k|      }
  165|  88.2k|   }
_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|  88.2k|      {
   73|  88.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|  88.2k|         else {
   84|  88.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.2k|      }
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|  88.2k|      {
   59|  88.2k|         return Rule::match( in );
   60|  88.2k|      }
_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|  20.7k|   {
  104|  20.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  20.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|  20.7k|   }
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|  20.7k|      {
   44|  20.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.7k|      }
_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|  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: 20.7k, False: 37]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  20.7k|            else if constexpr( has_apply0_bool ) {
  153|  20.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.7k|            }
  155|  20.7k|         }
  156|  20.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.7k, False: 37]
  ------------------
  157|  20.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.7k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|  20.7k|         (void)m( result );
  163|  20.7k|         return result;
  164|  20.7k|      }
  165|  20.7k|   }
_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|  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_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|  20.7k|      {
   44|  20.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  41.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.5k|      else {
  108|  41.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  41.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.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|  41.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|  41.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|  41.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|  41.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.5k, False: 37]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  41.5k|            else if constexpr( has_apply0_bool ) {
  153|  41.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.5k|            }
  155|  41.5k|         }
  156|  41.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.5k, False: 37]
  ------------------
  157|  41.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.5k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|  41.5k|         (void)m( result );
  163|  41.5k|         return result;
  164|  41.5k|      }
  165|  41.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  41.5k|      {
   73|  41.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|  41.5k|         else {
   84|  41.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  41.5k|      {
   59|  41.5k|         return Rule::match( in );
   60|  41.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  67.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  67.4k|      else {
  108|  67.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  67.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  67.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|  67.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|  67.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|  67.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|  67.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|  67.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|  67.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  67.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  67.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  67.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|  67.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  67.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  67.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|  67.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  67.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  67.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  67.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  67.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.9k, False: 38.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|  28.9k|            else if constexpr( has_apply0_bool ) {
  153|  28.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.9k|            }
  155|  28.9k|         }
  156|  67.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.9k, False: 38.5k]
  ------------------
  157|  28.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.9k|         }
  159|  38.5k|         else {
  160|  38.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.5k|         }
  162|  67.4k|         (void)m( result );
  163|  67.4k|         return result;
  164|  67.4k|      }
  165|  67.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|  67.4k|      {
   73|  67.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|  67.4k|         else {
   84|  67.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  67.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  67.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|  67.4k|      {
   44|  67.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  67.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|   100k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   100k|      else {
  108|   100k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   100k|         using iterator_t = typename ParseInput::iterator_t;
  111|   100k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   100k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   100k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   100k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   100k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   100k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   100k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   100k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   100k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   100k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   100k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   100k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   100k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   100k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   100k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   100k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   100k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   100k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.7k, False: 66.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|  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|   100k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.7k, False: 66.4k]
  ------------------
  157|  33.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.7k|         }
  159|  66.4k|         else {
  160|  66.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  66.4k|         }
  162|   100k|         (void)m( result );
  163|   100k|         return result;
  164|   100k|      }
  165|   100k|   }
_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|   100k|      {
   73|   100k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   100k|         else {
   84|   100k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   100k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   100k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   100k|      {
   59|   100k|         return Rule::match( in );
   60|   100k|      }
_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|  28.9k|   {
  104|  28.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  28.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  28.9k|   }
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|  28.9k|      {
   44|  28.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.9k|      }
_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|  28.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.9k|      else {
  108|  28.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.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|  28.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|  28.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|  28.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|  28.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|  28.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|  28.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.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|  28.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.9k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  28.9k|            else if constexpr( has_apply0_bool ) {
  153|  28.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.9k|            }
  155|  28.9k|         }
  156|  28.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.9k, False: 0]
  ------------------
  157|  28.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  28.9k|         (void)m( result );
  163|  28.9k|         return result;
  164|  28.9k|      }
  165|  28.9k|   }
_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|  28.9k|      {
   73|  28.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|  28.9k|         else {
   84|  28.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.9k|      }
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|  28.9k|      {
   44|  28.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.9k|      }
_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|  38.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.5k|      else {
  108|  38.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.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|  38.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|  38.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|  38.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|  38.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.2k, False: 1.24k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  37.2k|            else if constexpr( has_apply0_bool ) {
  153|  37.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.2k|            }
  155|  37.2k|         }
  156|  38.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.2k, False: 1.24k]
  ------------------
  157|  37.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.2k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|  38.5k|         (void)m( result );
  163|  38.5k|         return result;
  164|  38.5k|      }
  165|  38.5k|   }
_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|  38.5k|      {
   73|  38.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|  38.5k|         else {
   84|  38.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  38.5k|      {
   59|  38.5k|         return Rule::match( in );
   60|  38.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.24k|      else {
  108|  1.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.20k, False: 39]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.20k|            else if constexpr( has_apply0_bool ) {
  153|  1.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.20k|            }
  155|  1.20k|         }
  156|  1.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.20k, False: 39]
  ------------------
  157|  1.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.20k|         }
  159|     39|         else {
  160|     39|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     39|         }
  162|  1.24k|         (void)m( result );
  163|  1.24k|         return result;
  164|  1.24k|      }
  165|  1.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.24k|      {
   73|  1.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|  1.24k|         else {
   84|  1.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.24k|      {
   59|  1.24k|         return Rule::match( in );
   60|  1.24k|      }
_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.71M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.71M|      else {
  108|  7.71M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.71M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.71M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.71M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.71M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.71M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.71M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.71M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.71M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.71M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.71M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.71M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.71M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.71M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.71M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.71M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.71M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.71M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.71M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.71M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.71M, False: 169]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.71M|            else if constexpr( has_apply0_bool ) {
  153|  7.71M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.71M|            }
  155|  7.71M|         }
  156|  7.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.71M, False: 169]
  ------------------
  157|  7.71M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.71M|         }
  159|    169|         else {
  160|    169|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    169|         }
  162|  7.71M|         (void)m( result );
  163|  7.71M|         return result;
  164|  7.71M|      }
  165|  7.71M|   }
_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.71M|      {
   73|  7.71M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.71M|         else {
   84|  7.71M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.71M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.71M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.71M|      {
   59|  7.71M|         return Rule::match( in );
   60|  7.71M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.5k|      else {
  108|  16.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.95k, False: 13.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|  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|  16.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.95k, False: 13.6k]
  ------------------
  157|  2.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.95k|         }
  159|  13.6k|         else {
  160|  13.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.6k|         }
  162|  16.5k|         (void)m( result );
  163|  16.5k|         return result;
  164|  16.5k|      }
  165|  16.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.5k|      {
   73|  16.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|  16.5k|         else {
   84|  16.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.5k|      {
   44|  16.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.5k|      else {
  108|  16.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.95k, False: 13.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|  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|  16.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.95k, False: 13.6k]
  ------------------
  157|  2.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.95k|         }
  159|  13.6k|         else {
  160|  13.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.6k|         }
  162|  16.5k|         (void)m( result );
  163|  16.5k|         return result;
  164|  16.5k|      }
  165|  16.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.5k|      {
   73|  16.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|  16.5k|         else {
   84|  16.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.5k|      {
   44|  16.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.5k|      else {
  108|  16.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 16.5k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.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|  16.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|  16.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|  16.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 16.5k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.00k, False: 10.5k]
  ------------------
  143|  6.00k|            if constexpr( has_apply_void ) {
  144|  6.00k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.00k|         }
  156|  16.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.99k, False: 10.5k]
  ------------------
  157|  5.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.99k|         }
  159|  10.5k|         else {
  160|  10.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.5k|         }
  162|  16.5k|         (void)m( result );
  163|  16.5k|         return result;
  164|  16.5k|      }
  165|  16.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.5k|      {
   73|  16.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|  16.5k|         else {
   84|  16.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.5k|      {
   59|  16.5k|         return Rule::match( in );
   60|  16.5k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   645k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   645k|      else {
  108|   645k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   645k|         using iterator_t = typename ParseInput::iterator_t;
  111|   645k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   645k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   645k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   645k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   645k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   645k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   645k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   645k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   645k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   645k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   645k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   645k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   645k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   645k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   645k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   645k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   645k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   645k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 643k, 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|   643k|            else if constexpr( has_apply0_bool ) {
  153|   643k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   643k|            }
  155|   643k|         }
  156|   645k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 643k, False: 2.09k]
  ------------------
  157|   643k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   643k|         }
  159|  2.09k|         else {
  160|  2.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.09k|         }
  162|   645k|         (void)m( result );
  163|   645k|         return result;
  164|   645k|      }
  165|   645k|   }
_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|   645k|      {
   73|   645k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   645k|         else {
   84|   645k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   645k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   645k|      }
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|   645k|      {
   44|   645k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   645k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   645k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   645k|      else {
  108|   645k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   645k|         using iterator_t = typename ParseInput::iterator_t;
  111|   645k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   645k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   645k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   645k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   645k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   645k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   645k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   645k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   645k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   645k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   645k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   645k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   645k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   645k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   645k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   645k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   645k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   645k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 643k, 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|   643k|            else if constexpr( has_apply0_bool ) {
  153|   643k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   643k|            }
  155|   643k|         }
  156|   645k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 643k, False: 2.09k]
  ------------------
  157|   643k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   643k|         }
  159|  2.09k|         else {
  160|  2.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.09k|         }
  162|   645k|         (void)m( result );
  163|   645k|         return result;
  164|   645k|      }
  165|   645k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   645k|      {
   73|   645k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   645k|         else {
   84|   645k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   645k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   645k|      }
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|   645k|      {
   59|   645k|         return Rule::match( in );
   60|   645k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   681k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   681k|      else {
  108|   681k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   681k|         using iterator_t = typename ParseInput::iterator_t;
  111|   681k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   681k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   681k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   681k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   681k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   681k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   681k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   681k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   681k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   681k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   681k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   681k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   681k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   681k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   681k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   681k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   681k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   681k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.0k, False: 650k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  31.0k|            else if constexpr( has_apply0_bool ) {
  153|  31.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.0k|            }
  155|  31.0k|         }
  156|   681k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.0k, False: 650k]
  ------------------
  157|  31.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.0k|         }
  159|   650k|         else {
  160|   650k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   650k|         }
  162|   681k|         (void)m( result );
  163|   681k|         return result;
  164|   681k|      }
  165|   681k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   681k|      {
   73|   681k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   681k|         else {
   84|   681k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   681k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   681k|      }
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|   681k|      {
   59|   681k|         return Rule::match( in );
   60|   681k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.95k, False: 3.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|  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|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.95k, False: 3.02k]
  ------------------
  157|  2.95k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.95k|         }
  159|  3.02k|         else {
  160|  3.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.02k|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.97k|      {
   44|  5.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.97k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 4.05k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 4.05k]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|  4.05k|         else {
  160|  4.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.05k|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.97k|      {
   44|  5.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.97k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.97k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.97k|            else if constexpr( has_apply0_bool ) {
  153|  5.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.97k|            }
  155|  5.97k|         }
  156|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.97k, False: 0]
  ------------------
  157|  5.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.97k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.97k|      {
   44|  5.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.97k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|  5.97k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.97k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.97k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.97k|      {
   44|  5.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.97k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.97k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  5.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|  5.97k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.97k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.97k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.32k, False: 4.65k]
  ------------------
  143|  1.32k|            if constexpr( has_apply_void ) {
  144|  1.32k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.32k|         }
  156|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.32k, False: 4.65k]
  ------------------
  157|  1.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.32k|         }
  159|  4.65k|         else {
  160|  4.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.65k|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.97k|      {
   44|  5.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.97k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 109, False: 5.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|    109|            else if constexpr( has_apply0_bool ) {
  153|    109|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    109|            }
  155|    109|         }
  156|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 109, False: 5.86k]
  ------------------
  157|    109|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    109|         }
  159|  5.86k|         else {
  160|  5.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.86k|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.97k|      {
   59|  5.97k|         return Rule::match( in );
   60|  5.97k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.86k|      else {
  108|  5.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 215, False: 5.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|    215|            else if constexpr( has_apply0_bool ) {
  153|    215|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    215|            }
  155|    215|         }
  156|  5.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 215, False: 5.64k]
  ------------------
  157|    215|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    215|         }
  159|  5.64k|         else {
  160|  5.64k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.64k|         }
  162|  5.86k|         (void)m( result );
  163|  5.86k|         return result;
  164|  5.86k|      }
  165|  5.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.86k|      {
   73|  5.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|  5.86k|         else {
   84|  5.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.86k|      {
   59|  5.86k|         return Rule::match( in );
   60|  5.86k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.64k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.64k|      else {
  108|  5.64k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.64k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.64k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.64k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.64k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.64k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.64k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.64k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.64k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.64k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.64k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.64k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.64k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.64k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.64k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.64k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.64k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.64k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.64k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.64k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 217, False: 5.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  5.64k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 217, False: 5.43k]
  ------------------
  157|    217|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    217|         }
  159|  5.43k|         else {
  160|  5.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.43k|         }
  162|  5.64k|         (void)m( result );
  163|  5.64k|         return result;
  164|  5.64k|      }
  165|  5.64k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.64k|      {
   73|  5.64k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.64k|         else {
   84|  5.64k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.64k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.64k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.64k|      {
   59|  5.64k|         return Rule::match( in );
   60|  5.64k|      }
_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.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.43k|      else {
  108|  5.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.43k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 307, False: 5.12k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    307|            else if constexpr( has_apply0_bool ) {
  153|    307|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    307|            }
  155|    307|         }
  156|  5.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 307, False: 5.12k]
  ------------------
  157|    307|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    307|         }
  159|  5.12k|         else {
  160|  5.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.12k|         }
  162|  5.43k|         (void)m( result );
  163|  5.43k|         return result;
  164|  5.43k|      }
  165|  5.43k|   }
_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.43k|      {
   73|  5.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.43k|         else {
   84|  5.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.43k|      {
   59|  5.43k|         return Rule::match( in );
   60|  5.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.12k|      else {
  108|  5.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 272, False: 4.85k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    272|            else if constexpr( has_apply0_bool ) {
  153|    272|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    272|            }
  155|    272|         }
  156|  5.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 272, False: 4.85k]
  ------------------
  157|    272|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    272|         }
  159|  4.85k|         else {
  160|  4.85k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.85k|         }
  162|  5.12k|         (void)m( result );
  163|  5.12k|         return result;
  164|  5.12k|      }
  165|  5.12k|   }
_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.12k|      {
   73|  5.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|  5.12k|         else {
   84|  5.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.12k|      }
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.12k|      {
   59|  5.12k|         return Rule::match( in );
   60|  5.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.85k|      else {
  108|  4.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.85k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 200, False: 4.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    200|            else if constexpr( has_apply0_bool ) {
  153|    200|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    200|            }
  155|    200|         }
  156|  4.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 200, False: 4.65k]
  ------------------
  157|    200|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    200|         }
  159|  4.65k|         else {
  160|  4.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.65k|         }
  162|  4.85k|         (void)m( result );
  163|  4.85k|         return result;
  164|  4.85k|      }
  165|  4.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.85k|      {
   73|  4.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.85k|         else {
   84|  4.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.85k|      {
   59|  4.85k|         return Rule::match( in );
   60|  4.85k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.97k|      else {
  108|  5.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.75k, 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|  3.75k|            else if constexpr( has_apply0_bool ) {
  153|  3.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.75k|            }
  155|  3.75k|         }
  156|  5.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.75k, False: 2.21k]
  ------------------
  157|  3.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.75k|         }
  159|  2.21k|         else {
  160|  2.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.21k|         }
  162|  5.97k|         (void)m( result );
  163|  5.97k|         return result;
  164|  5.97k|      }
  165|  5.97k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.97k|      {
   73|  5.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|  5.97k|         else {
   84|  5.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.97k|      {
   59|  5.97k|         return Rule::match( in );
   60|  5.97k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.27k|      else {
  108|  6.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.27k, 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.27k|            else if constexpr( has_apply0_bool ) {
  153|  6.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.27k|            }
  155|  6.27k|         }
  156|  6.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.27k, False: 0]
  ------------------
  157|  6.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.27k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.27k|         (void)m( result );
  163|  6.27k|         return result;
  164|  6.27k|      }
  165|  6.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  6.27k|      {
   73|  6.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|  6.27k|         else {
   84|  6.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.27k|      {
   44|  6.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.27k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.75k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.75k|      else {
  108|  3.75k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.75k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.75k|         constexpr bool has_apply_void = enable_action && internal::has_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.75k|         constexpr bool has_apply_bool = enable_action && internal::has_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.75k|         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.75k|         constexpr bool has_apply0_void = enable_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.75k|         constexpr bool has_apply0_bool = enable_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.75k|         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.75k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.75k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.75k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.75k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.75k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.75k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.75k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.75k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.75k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.75k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.75k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.75k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.52k, 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.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|  3.75k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.52k, False: 1.23k]
  ------------------
  157|  2.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.52k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  3.75k|         (void)m( result );
  163|  3.75k|         return result;
  164|  3.75k|      }
  165|  3.75k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.75k|      {
   73|  3.75k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.75k|         else {
   84|  3.75k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.75k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.75k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.75k|      {
   44|  3.75k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.75k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.61k|   {
  104|  3.61k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.61k|         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.61k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.61k|      {
   44|  3.61k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.61k|      }
_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|   638k|   {
  104|   638k|      if constexpr( !Control< Rule >::enable ) {
  105|   638k|         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|   638k|   }
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|   638k|      {
   44|   638k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   638k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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: 1.92k, False: 603]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  2.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 603]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|    603|         else {
  160|    603|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    603|         }
  162|  2.52k|         (void)m( result );
  163|  2.52k|         return result;
  164|  2.52k|      }
  165|  2.52k|   }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   643k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   643k|      else {
  108|   643k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   643k|         using iterator_t = typename ParseInput::iterator_t;
  111|   643k|         constexpr bool has_apply_void = 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|   643k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   643k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 643k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   643k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   643k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   643k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   643k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   643k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   643k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   643k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   643k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   643k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   643k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   643k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 643k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   643k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   643k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   643k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   643k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, False: 1.66k]
  ------------------
  143|   641k|            if constexpr( has_apply_void ) {
  144|   641k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   641k|         }
  156|   643k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 639k, False: 3.59k]
  ------------------
  157|   639k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   639k|         }
  159|  3.59k|         else {
  160|  3.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.59k|         }
  162|   643k|         (void)m( result );
  163|   643k|         return result;
  164|   643k|      }
  165|   643k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   643k|      {
   73|   643k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   643k|         else {
   84|   643k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   643k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   643k|      }
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|   643k|      {
   44|   643k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   643k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   643k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   643k|      else {
  108|   643k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   643k|         using iterator_t = typename ParseInput::iterator_t;
  111|   643k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   643k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   643k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   643k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   643k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   643k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   643k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   643k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   643k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   643k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   643k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   643k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   643k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   643k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   643k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   643k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   643k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   643k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 643k, 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|   643k|            else if constexpr( has_apply0_bool ) {
  153|   643k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   643k|            }
  155|   643k|         }
  156|   643k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 643k, False: 0]
  ------------------
  157|   643k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   643k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   643k|         (void)m( result );
  163|   643k|         return result;
  164|   643k|      }
  165|   643k|   }
_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|   643k|      {
   73|   643k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   643k|         else {
   84|   643k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   643k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   643k|      }
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|   643k|      {
   44|   643k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   643k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   643k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   643k|      else {
  108|   643k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   643k|         using iterator_t = typename ParseInput::iterator_t;
  111|   643k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   643k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   643k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   643k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   643k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   643k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   643k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   643k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   643k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   643k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   643k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   643k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   643k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   643k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   643k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   643k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   643k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   643k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 498, False: 642k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    498|            else if constexpr( has_apply0_bool ) {
  153|    498|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    498|            }
  155|    498|         }
  156|   643k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 498, False: 642k]
  ------------------
  157|    498|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    498|         }
  159|   642k|         else {
  160|   642k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   642k|         }
  162|   643k|         (void)m( result );
  163|   643k|         return result;
  164|   643k|      }
  165|   643k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   643k|      {
   73|   643k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   643k|         else {
   84|   643k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   643k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   643k|      }
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|   643k|      {
   59|   643k|         return Rule::match( in );
   60|   643k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   643k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   643k|      else {
  108|   643k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   643k|         using iterator_t = typename ParseInput::iterator_t;
  111|   643k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   643k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   643k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   643k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   643k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   643k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   643k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   643k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   643k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   643k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   643k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   643k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   643k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   643k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   643k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   643k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   643k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   643k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, 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|   641k|            else if constexpr( has_apply0_bool ) {
  153|   641k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   641k|            }
  155|   641k|         }
  156|   643k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 641k, False: 1.29k]
  ------------------
  157|   641k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   641k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|   643k|         (void)m( result );
  163|   643k|         return result;
  164|   643k|      }
  165|   643k|   }
_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|   643k|      {
   73|   643k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   643k|         else {
   84|   643k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   643k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   643k|      }
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|   643k|      {
   44|   643k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   643k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   643k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   643k|      else {
  108|   643k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   643k|         using iterator_t = typename ParseInput::iterator_t;
  111|   643k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   643k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   643k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   643k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   643k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   643k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   643k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   643k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   643k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   643k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   643k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   643k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   643k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   643k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   643k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   643k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   643k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   643k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, 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|   641k|            else if constexpr( has_apply0_bool ) {
  153|   641k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   641k|            }
  155|   641k|         }
  156|   643k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 641k, False: 1.29k]
  ------------------
  157|   641k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   641k|         }
  159|  1.29k|         else {
  160|  1.29k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.29k|         }
  162|   643k|         (void)m( result );
  163|   643k|         return result;
  164|   643k|      }
  165|   643k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   643k|      {
   73|   643k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   643k|         else {
   84|   643k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   643k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   643k|      }
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|   643k|      {
   59|   643k|         return Rule::match( in );
   60|   643k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   641k|            else if constexpr( has_apply0_bool ) {
  153|   641k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   641k|            }
  155|   641k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 641k, False: 0]
  ------------------
  157|   641k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   641k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  29.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.4M|      else {
  108|  29.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.4M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.4M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.4M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.4M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.4M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.4M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.4M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.4M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  29.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.8M, False: 641k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  28.8M|            else if constexpr( has_apply0_bool ) {
  153|  28.8M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.8M|            }
  155|  28.8M|         }
  156|  29.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.8M, False: 641k]
  ------------------
  157|  28.8M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.8M|         }
  159|   641k|         else {
  160|   641k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   641k|         }
  162|  29.4M|         (void)m( result );
  163|  29.4M|         return result;
  164|  29.4M|      }
  165|  29.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  29.4M|      {
   73|  29.4M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.4M|         else {
   84|  29.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.4M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  29.4M|      {
   59|  29.4M|         return Rule::match( in );
   60|  29.4M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, False: 372]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   641k|            else if constexpr( has_apply0_bool ) {
  153|   641k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   641k|            }
  155|   641k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 641k, False: 372]
  ------------------
  157|   641k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   641k|         }
  159|    372|         else {
  160|    372|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    372|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_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|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.7k, False: 606k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.7k|            else if constexpr( has_apply0_bool ) {
  153|  35.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.7k|            }
  155|  35.7k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.7k, False: 606k]
  ------------------
  157|  35.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.7k|         }
  159|   606k|         else {
  160|   606k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   606k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_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|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.1k, False: 605k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  36.1k|            else if constexpr( has_apply0_bool ) {
  153|  36.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.1k|            }
  155|  36.1k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.1k, False: 605k]
  ------------------
  157|  36.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.1k|         }
  159|   605k|         else {
  160|   605k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   605k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   641k|      {
   59|   641k|         return Rule::match( in );
   60|   641k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  36.1k|   {
  104|  36.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  36.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|  36.1k|   }
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|  36.1k|      {
   44|  36.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.1k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  36.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.1k|      else {
  108|  36.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.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|  36.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|  36.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|  36.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|  36.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|  36.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|  36.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.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|  36.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.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|  36.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.7k, False: 372]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.7k|            else if constexpr( has_apply0_bool ) {
  153|  35.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.7k|            }
  155|  35.7k|         }
  156|  36.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.7k, False: 372]
  ------------------
  157|  35.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.7k|         }
  159|    372|         else {
  160|    372|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    372|         }
  162|  36.1k|         (void)m( result );
  163|  36.1k|         return result;
  164|  36.1k|      }
  165|  36.1k|   }
_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|  36.1k|      {
   73|  36.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|  36.1k|         else {
   84|  36.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.1k|      }
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|  36.1k|      {
   44|  36.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.0M|      else {
  108|  45.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.7k, False: 45.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|  35.7k|            else if constexpr( has_apply0_bool ) {
  153|  35.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.7k|            }
  155|  35.7k|         }
  156|  45.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.7k, False: 45.0M]
  ------------------
  157|  35.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.7k|         }
  159|  45.0M|         else {
  160|  45.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  45.0M|         }
  162|  45.0M|         (void)m( result );
  163|  45.0M|         return result;
  164|  45.0M|      }
  165|  45.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  45.0M|      {
   73|  45.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|  45.0M|         else {
   84|  45.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0M|      }
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|  45.0M|      {
   59|  45.0M|         return Rule::match( in );
   60|  45.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.0M|      else {
  108|  45.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.0M, False: 372]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.0M|            else if constexpr( has_apply0_bool ) {
  153|  45.0M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.0M|            }
  155|  45.0M|         }
  156|  45.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.0M, False: 372]
  ------------------
  157|  45.0M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.0M|         }
  159|    372|         else {
  160|    372|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    372|         }
  162|  45.0M|         (void)m( result );
  163|  45.0M|         return result;
  164|  45.0M|      }
  165|  45.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  45.0M|      {
   73|  45.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|  45.0M|         else {
   84|  45.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0M|      }
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|  45.0M|      {
   44|  45.0M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.0M|      else {
  108|  45.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 186k, False: 44.8M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   186k|            else if constexpr( has_apply0_bool ) {
  153|   186k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   186k|            }
  155|   186k|         }
  156|  45.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 186k, False: 44.8M]
  ------------------
  157|   186k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   186k|         }
  159|  44.8M|         else {
  160|  44.8M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.8M|         }
  162|  45.0M|         (void)m( result );
  163|  45.0M|         return result;
  164|  45.0M|      }
  165|  45.0M|   }
_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|  45.0M|      {
   73|  45.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|  45.0M|         else {
   84|  45.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0M|      }
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|  45.0M|      {
   44|  45.0M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.0M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  45.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.0M|      else {
  108|  45.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 186k, False: 44.8M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   186k|            else if constexpr( has_apply0_bool ) {
  153|   186k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   186k|            }
  155|   186k|         }
  156|  45.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 186k, False: 44.8M]
  ------------------
  157|   186k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   186k|         }
  159|  44.8M|         else {
  160|  44.8M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.8M|         }
  162|  45.0M|         (void)m( result );
  163|  45.0M|         return result;
  164|  45.0M|      }
  165|  45.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  45.0M|      {
   73|  45.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|  45.0M|         else {
   84|  45.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.0M|      }
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|  45.0M|      {
   59|  45.0M|         return Rule::match( in );
   60|  45.0M|      }
_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|   186k|   {
  104|   186k|      if constexpr( !Control< Rule >::enable ) {
  105|   186k|         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|   186k|   }
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|   186k|      {
   44|   186k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   186k|      }
_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|   186k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   186k|      else {
  108|   186k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   186k|         using iterator_t = typename ParseInput::iterator_t;
  111|   186k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   186k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   186k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   186k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   186k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   186k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   186k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   186k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   186k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   186k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   186k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   186k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   186k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   186k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   186k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   186k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   186k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   186k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 186k, 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|   186k|            else if constexpr( has_apply0_bool ) {
  153|   186k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   186k|            }
  155|   186k|         }
  156|   186k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 186k, False: 102]
  ------------------
  157|   186k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   186k|         }
  159|    102|         else {
  160|    102|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    102|         }
  162|   186k|         (void)m( result );
  163|   186k|         return result;
  164|   186k|      }
  165|   186k|   }
_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|   186k|      {
   73|   186k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   186k|         else {
   84|   186k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   186k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   186k|      }
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|   186k|      {
   44|   186k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   186k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   186k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   186k|      else {
  108|   186k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   186k|         using iterator_t = typename ParseInput::iterator_t;
  111|   186k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   186k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   186k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   186k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   186k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   186k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   186k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   186k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   186k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   186k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   186k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   186k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   186k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   186k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   186k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   186k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   186k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   186k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 148k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   186k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 148k]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|   148k|         else {
  160|   148k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   148k|         }
  162|   186k|         (void)m( result );
  163|   186k|         return result;
  164|   186k|      }
  165|   186k|   }
_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|   186k|      {
   73|   186k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   186k|         else {
   84|   186k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   186k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   186k|      }
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|   186k|      {
   44|   186k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   186k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   186k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   186k|      else {
  108|   186k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   186k|         using iterator_t = typename ParseInput::iterator_t;
  111|   186k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   186k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   186k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   186k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   186k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   186k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   186k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   186k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   186k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   186k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   186k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   186k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   186k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   186k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   186k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   186k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   186k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   186k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.0k, False: 148k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   186k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.0k, False: 148k]
  ------------------
  157|  38.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.0k|         }
  159|   148k|         else {
  160|   148k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   148k|         }
  162|   186k|         (void)m( result );
  163|   186k|         return result;
  164|   186k|      }
  165|   186k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   186k|      {
   73|   186k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   186k|         else {
   84|   186k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   186k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   186k|      }
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|   186k|      {
   59|   186k|         return Rule::match( in );
   60|   186k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|  38.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.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|  38.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.0k|      else {
  108|  38.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.9k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  38.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.9k, False: 41]
  ------------------
  157|  37.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.9k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  38.0k|         (void)m( result );
  163|  38.0k|         return result;
  164|  38.0k|      }
  165|  38.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  38.0k|      {
   73|  38.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|  38.0k|         else {
   84|  38.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.0k|      {
   44|  38.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  75.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.9k|      else {
  108|  75.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  75.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  75.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|  75.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|  75.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|  75.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|  75.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  75.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.9k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  75.9k|            else if constexpr( has_apply0_bool ) {
  153|  75.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.9k|            }
  155|  75.9k|         }
  156|  75.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.9k, False: 41]
  ------------------
  157|  75.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.9k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  75.9k|         (void)m( result );
  163|  75.9k|         return result;
  164|  75.9k|      }
  165|  75.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  75.9k|      {
   73|  75.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.9k|         else {
   84|  75.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  75.9k|      {
   59|  75.9k|         return Rule::match( in );
   60|  75.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   148k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   148k|      else {
  108|   148k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   148k|         using iterator_t = typename ParseInput::iterator_t;
  111|   148k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   148k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   148k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   148k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   148k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   148k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   148k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   148k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   148k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   148k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   148k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   148k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   148k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   148k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   148k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   148k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   148k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   148k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 112k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  36.0k|            else if constexpr( has_apply0_bool ) {
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|   148k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 112k]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|   112k|         else {
  160|   112k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   112k|         }
  162|   148k|         (void)m( result );
  163|   148k|         return result;
  164|   148k|      }
  165|   148k|   }
_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|   148k|      {
   73|   148k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   148k|         else {
   84|   148k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   148k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   148k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   148k|      {
   44|   148k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   148k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   192k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 46.0k, False: 146k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  46.0k|            else if constexpr( has_apply0_bool ) {
  153|  46.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  46.0k|            }
  155|  46.0k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.0k, False: 146k]
  ------------------
  157|  46.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.0k|         }
  159|   146k|         else {
  160|   146k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   146k|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   192k|      {
   59|   192k|         return Rule::match( in );
   60|   192k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  36.0k|   {
  104|  36.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  36.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  36.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_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|  36.0k|      {
   44|  36.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.0k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  36.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.0k|      else {
  108|  36.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  36.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  36.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  36.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  36.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  36.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  36.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  36.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  36.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 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|  36.0k|            else if constexpr( has_apply0_bool ) {
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|  36.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 0]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  36.0k|         (void)m( result );
  163|  36.0k|         return result;
  164|  36.0k|      }
  165|  36.0k|   }
_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|  36.0k|      {
   73|  36.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  36.0k|         else {
   84|  36.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  36.0k|      {
   44|  36.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   112k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   112k|      else {
  108|   112k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   112k|         using iterator_t = typename ParseInput::iterator_t;
  111|   112k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   112k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   112k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   112k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   112k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   112k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   112k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   112k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   112k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   112k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   112k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   112k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   112k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   112k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   112k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   112k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   112k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   112k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 112k, False: 491]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   112k|            else if constexpr( has_apply0_bool ) {
  153|   112k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   112k|            }
  155|   112k|         }
  156|   112k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 112k, False: 491]
  ------------------
  157|   112k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   112k|         }
  159|    491|         else {
  160|    491|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    491|         }
  162|   112k|         (void)m( result );
  163|   112k|         return result;
  164|   112k|      }
  165|   112k|   }
_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|   112k|      {
   73|   112k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   112k|         else {
   84|   112k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   112k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   112k|      }
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|   112k|      {
   59|   112k|         return Rule::match( in );
   60|   112k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    491|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    491|      else {
  108|    491|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    491|         using iterator_t = typename ParseInput::iterator_t;
  111|    491|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    491|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    491|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    491|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    491|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    491|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    491|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    491|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    491|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    491|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    491|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    491|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    491|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    491|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    491|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    491|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    491|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    491|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 430, 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|    430|            else if constexpr( has_apply0_bool ) {
  153|    430|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    430|            }
  155|    430|         }
  156|    491|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 430, False: 61]
  ------------------
  157|    430|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    430|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|    491|         (void)m( result );
  163|    491|         return result;
  164|    491|      }
  165|    491|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    491|      {
   73|    491|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    491|         else {
   84|    491|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    491|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    491|      }
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|    491|      {
   59|    491|         return Rule::match( in );
   60|    491|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.8M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.8M|      else {
  108|  44.8M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.8M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.8M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.8M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.8M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.8M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.8M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.8M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.8M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.8M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.8M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.8M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.8M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.8M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.8M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.8M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.8M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.8M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.8M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.8M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.8M, 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|  44.8M|            else if constexpr( has_apply0_bool ) {
  153|  44.8M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.8M|            }
  155|  44.8M|         }
  156|  44.8M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.8M, False: 270]
  ------------------
  157|  44.8M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.8M|         }
  159|    270|         else {
  160|    270|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    270|         }
  162|  44.8M|         (void)m( result );
  163|  44.8M|         return result;
  164|  44.8M|      }
  165|  44.8M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.8M|      {
   73|  44.8M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.8M|         else {
   84|  44.8M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.8M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.8M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.8M|      {
   59|  44.8M|         return Rule::match( in );
   60|  44.8M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.3k|      else {
  108|  11.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.65k, False: 7.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.65k|            else if constexpr( has_apply0_bool ) {
  153|  3.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.65k|            }
  155|  3.65k|         }
  156|  11.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.65k, False: 7.65k]
  ------------------
  157|  3.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.65k|         }
  159|  7.65k|         else {
  160|  7.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.65k|         }
  162|  11.3k|         (void)m( result );
  163|  11.3k|         return result;
  164|  11.3k|      }
  165|  11.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.3k|      {
   73|  11.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|  11.3k|         else {
   84|  11.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.3k|      {
   44|  11.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.3k|      else {
  108|  11.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.65k, False: 7.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.65k|            else if constexpr( has_apply0_bool ) {
  153|  3.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.65k|            }
  155|  3.65k|         }
  156|  11.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.65k, False: 7.65k]
  ------------------
  157|  3.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.65k|         }
  159|  7.65k|         else {
  160|  7.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.65k|         }
  162|  11.3k|         (void)m( result );
  163|  11.3k|         return result;
  164|  11.3k|      }
  165|  11.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.3k|      {
   73|  11.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|  11.3k|         else {
   84|  11.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.3k|      {
   44|  11.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.3k|      else {
  108|  11.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.36k, False: 6.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|  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|  11.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.36k, False: 6.94k]
  ------------------
  157|  4.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.36k|         }
  159|  6.94k|         else {
  160|  6.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.94k|         }
  162|  11.3k|         (void)m( result );
  163|  11.3k|         return result;
  164|  11.3k|      }
  165|  11.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.3k|      {
   73|  11.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|  11.3k|         else {
   84|  11.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.3k|      {
   59|  11.3k|         return Rule::match( in );
   60|  11.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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: 8.62k, False: 2.14k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.62k|            else if constexpr( has_apply0_bool ) {
  153|  8.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.62k|            }
  155|  8.62k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.62k, False: 2.14k]
  ------------------
  157|  8.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.62k|         }
  159|  2.14k|         else {
  160|  2.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.14k|         }
  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_modeE0ETtTpTyEN8usbguard10RuleParser13label_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_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.7k|      {
   44|  10.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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: 8.62k, False: 2.14k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.62k|            else if constexpr( has_apply0_bool ) {
  153|  8.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.62k|            }
  155|  8.62k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.62k, False: 2.14k]
  ------------------
  157|  8.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.62k|         }
  159|  2.14k|         else {
  160|  2.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.14k|         }
  162|  10.7k|         (void)m( result );
  163|  10.7k|         return result;
  164|  10.7k|      }
  165|  10.7k|   }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser13label_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_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  17.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.1k|      else {
  108|  17.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.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|  17.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|  17.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|  17.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|  17.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|  17.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|  17.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.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|  17.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.36k, False: 13.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.36k|            else if constexpr( has_apply0_bool ) {
  153|  3.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.36k|            }
  155|  3.36k|         }
  156|  17.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.36k, False: 13.7k]
  ------------------
  157|  3.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.36k|         }
  159|  13.7k|         else {
  160|  13.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.7k|         }
  162|  17.1k|         (void)m( result );
  163|  17.1k|         return result;
  164|  17.1k|      }
  165|  17.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  17.1k|      {
   73|  17.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|  17.1k|         else {
   84|  17.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.1k|      }
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|  17.1k|      {
   59|  17.1k|         return Rule::match( in );
   60|  17.1k|      }
_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.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.65k, False: 688]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.65k|            else if constexpr( has_apply0_bool ) {
  153|  3.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.65k|            }
  155|  3.65k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.65k, False: 688]
  ------------------
  157|  3.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.65k|         }
  159|    688|         else {
  160|    688|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    688|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_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.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 1.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|  2.39k|            else if constexpr( has_apply0_bool ) {
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 1.95k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  1.95k|         else {
  160|  1.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.95k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_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.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.34k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.34k|            else if constexpr( has_apply0_bool ) {
  153|  4.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.34k|            }
  155|  4.34k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.34k, False: 0]
  ------------------
  157|  4.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.34k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_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.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|  4.34k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.34k|         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.34k|   }
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.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.34k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.34k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.76k, False: 2.57k]
  ------------------
  143|  1.76k|            if constexpr( has_apply_void ) {
  144|  1.76k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.76k|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.76k, False: 2.57k]
  ------------------
  157|  1.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.76k|         }
  159|  2.57k|         else {
  160|  2.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.57k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_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.34k|      {
   73|  4.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|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_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.34k|      {
   44|  4.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.34k|      }
_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.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 240, False: 4.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|    240|            else if constexpr( has_apply0_bool ) {
  153|    240|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    240|            }
  155|    240|         }
  156|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 240, False: 4.10k]
  ------------------
  157|    240|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    240|         }
  159|  4.10k|         else {
  160|  4.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.10k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.34k|      {
   73|  4.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.34k|      {
   59|  4.34k|         return Rule::match( in );
   60|  4.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 255, False: 3.85k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    255|            else if constexpr( has_apply0_bool ) {
  153|    255|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    255|            }
  155|    255|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 255, False: 3.85k]
  ------------------
  157|    255|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    255|         }
  159|  3.85k|         else {
  160|  3.85k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.85k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_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|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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|  4.10k|      {
   59|  4.10k|         return Rule::match( in );
   60|  4.10k|      }
_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.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 402, 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|    402|            else if constexpr( has_apply0_bool ) {
  153|    402|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    402|            }
  155|    402|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 402, False: 3.44k]
  ------------------
  157|    402|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    402|         }
  159|  3.44k|         else {
  160|  3.44k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.44k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_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.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.85k|      {
   59|  3.85k|         return Rule::match( in );
   60|  3.85k|      }
_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.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: 200, 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|    200|            else if constexpr( has_apply0_bool ) {
  153|    200|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    200|            }
  155|    200|         }
  156|  3.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 200, False: 3.24k]
  ------------------
  157|    200|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    200|         }
  159|  3.24k|         else {
  160|  3.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.24k|         }
  162|  3.44k|         (void)m( result );
  163|  3.44k|         return result;
  164|  3.44k|      }
  165|  3.44k|   }
_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.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_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.44k|      {
   59|  3.44k|         return Rule::match( in );
   60|  3.44k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_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: 426, False: 2.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|    426|            else if constexpr( has_apply0_bool ) {
  153|    426|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    426|            }
  155|    426|         }
  156|  3.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 426, False: 2.82k]
  ------------------
  157|    426|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    426|         }
  159|  2.82k|         else {
  160|  2.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.82k|         }
  162|  3.24k|         (void)m( result );
  163|  3.24k|         return result;
  164|  3.24k|      }
  165|  3.24k|   }
_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.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_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.24k|      {
   59|  3.24k|         return Rule::match( in );
   60|  3.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.82k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 246, 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|    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|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 246, False: 2.57k]
  ------------------
  157|    246|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    246|         }
  159|  2.57k|         else {
  160|  2.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.57k|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.82k|      {
   59|  2.82k|         return Rule::match( in );
   60|  2.82k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.34k|      else {
  108|  4.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.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|  4.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|  4.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|  4.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|  4.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.60k, False: 1.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|  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|  4.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.60k, False: 1.74k]
  ------------------
  157|  2.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.60k|         }
  159|  1.74k|         else {
  160|  1.74k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.74k|         }
  162|  4.34k|         (void)m( result );
  163|  4.34k|         return result;
  164|  4.34k|      }
  165|  4.34k|   }
_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.34k|      {
   73|  4.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|  4.34k|         else {
   84|  4.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.34k|      {
   59|  4.34k|         return Rule::match( in );
   60|  4.34k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.12k|      else {
  108|  5.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.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|  5.12k|            else if constexpr( has_apply0_bool ) {
  153|  5.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.12k|            }
  155|  5.12k|         }
  156|  5.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.12k, False: 0]
  ------------------
  157|  5.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.12k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.12k|         (void)m( result );
  163|  5.12k|         return result;
  164|  5.12k|      }
  165|  5.12k|   }
_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|  5.12k|      {
   73|  5.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|  5.12k|         else {
   84|  5.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.12k|      }
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|  5.12k|      {
   44|  5.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.12k|      }
_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.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.51k, False: 83]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.51k|            else if constexpr( has_apply0_bool ) {
  153|  2.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.51k|            }
  155|  2.51k|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.51k, False: 83]
  ------------------
  157|  2.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.51k|         }
  159|     83|         else {
  160|     83|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     83|         }
  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_13label_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_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.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_13label_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_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.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_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.63k|   {
  104|  4.63k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.63k|         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.63k|   }
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.63k|      {
   44|  4.63k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.63k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.51k|      else {
  108|  2.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.51k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.51k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.51k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.51k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 124]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.39k|            else if constexpr( has_apply0_bool ) {
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  2.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 124]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|    124|         else {
  160|    124|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    124|         }
  162|  2.51k|         (void)m( result );
  163|  2.51k|         return result;
  164|  2.51k|      }
  165|  2.51k|   }
_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.51k|      {
   73|  2.51k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.51k|         else {
   84|  2.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.51k|      {
   59|  2.51k|         return Rule::match( in );
   60|  2.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.08k|      else {
  108|  7.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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): [True: 0, Folded]
  ------------------
  112|  7.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|  7.08k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.08k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.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|  7.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|  7.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|  7.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.08k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.94k, False: 1.13k]
  ------------------
  143|  5.94k|            if constexpr( has_apply_void ) {
  144|  5.94k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.94k|         }
  156|  7.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.90k, False: 1.17k]
  ------------------
  157|  5.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.90k|         }
  159|  1.17k|         else {
  160|  1.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.17k|         }
  162|  7.08k|         (void)m( result );
  163|  7.08k|         return result;
  164|  7.08k|      }
  165|  7.08k|   }
_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.08k|      {
   73|  7.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|  7.08k|         else {
   84|  7.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.08k|      }
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.08k|      {
   44|  7.08k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.08k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.08k|      else {
  108|  7.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.24k, False: 832]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  7.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.24k, False: 832]
  ------------------
  157|  6.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.24k|         }
  159|    832|         else {
  160|    832|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    832|         }
  162|  7.08k|         (void)m( result );
  163|  7.08k|         return result;
  164|  7.08k|      }
  165|  7.08k|   }
_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.08k|      {
   73|  7.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|  7.08k|         else {
   84|  7.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.08k|      }
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.08k|      {
   59|  7.08k|         return Rule::match( in );
   60|  7.08k|      }
_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.24k|   {
  104|  6.24k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.24k|   }
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.24k|      {
   44|  6.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.24k|      }
_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.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.24k|      else {
  108|  6.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.94k, 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|  5.94k|            else if constexpr( has_apply0_bool ) {
  153|  5.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.94k|            }
  155|  5.94k|         }
  156|  6.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.94k, False: 303]
  ------------------
  157|  5.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.94k|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|  6.24k|         (void)m( result );
  163|  6.24k|         return result;
  164|  6.24k|      }
  165|  6.24k|   }
_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.24k|      {
   73|  6.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|  6.24k|         else {
   84|  6.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.24k|      }
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.24k|      {
   44|  6.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.24k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.08M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.08M|      else {
  108|  9.08M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.08M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.08M|         constexpr bool has_apply_void = enable_action && internal::has_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.08M|         constexpr bool has_apply_bool = enable_action && internal::has_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.08M|         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.08M|         constexpr bool has_apply0_void = enable_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.08M|         constexpr bool has_apply0_bool = enable_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.08M|         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.08M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.08M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.08M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.08M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.08M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.08M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.08M|         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.08M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.08M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.08M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.08M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.08M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.94k, False: 9.08M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.94k|            else if constexpr( has_apply0_bool ) {
  153|  5.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.94k|            }
  155|  5.94k|         }
  156|  9.08M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.94k, False: 9.08M]
  ------------------
  157|  5.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.94k|         }
  159|  9.08M|         else {
  160|  9.08M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.08M|         }
  162|  9.08M|         (void)m( result );
  163|  9.08M|         return result;
  164|  9.08M|      }
  165|  9.08M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.08M|      {
   73|  9.08M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.08M|         else {
   84|  9.08M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.08M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.08M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.08M|      {
   59|  9.08M|         return Rule::match( in );
   60|  9.08M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.08M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.08M|      else {
  108|  9.08M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.08M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.08M|         constexpr bool has_apply_void = enable_action && internal::has_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.08M|         constexpr bool has_apply_bool = enable_action && internal::has_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.08M|         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.08M|         constexpr bool has_apply0_void = enable_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.08M|         constexpr bool has_apply0_bool = enable_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.08M|         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.08M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.08M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.08M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.08M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.08M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.08M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.08M|         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.08M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.08M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.08M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.08M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.08M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.08M, 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|  9.08M|            else if constexpr( has_apply0_bool ) {
  153|  9.08M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.08M|            }
  155|  9.08M|         }
  156|  9.08M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.08M, False: 303]
  ------------------
  157|  9.08M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.08M|         }
  159|    303|         else {
  160|    303|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    303|         }
  162|  9.08M|         (void)m( result );
  163|  9.08M|         return result;
  164|  9.08M|      }
  165|  9.08M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.08M|      {
   73|  9.08M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.08M|         else {
   84|  9.08M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.08M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.08M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.08M|      {
   44|  9.08M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.08M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.08M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.08M|      else {
  108|  9.08M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.08M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.08M|         constexpr bool has_apply_void = enable_action && internal::has_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.08M|         constexpr bool has_apply_bool = enable_action && internal::has_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.08M|         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.08M|         constexpr bool has_apply0_void = enable_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.08M|         constexpr bool has_apply0_bool = enable_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.08M|         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.08M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.08M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.08M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.08M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.08M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.08M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.08M|         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.08M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.08M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.08M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.08M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.08M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.6k, False: 8.99M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.6k|            else if constexpr( has_apply0_bool ) {
  153|  88.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.6k|            }
  155|  88.6k|         }
  156|  9.08M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.6k, False: 8.99M]
  ------------------
  157|  88.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.6k|         }
  159|  8.99M|         else {
  160|  8.99M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.99M|         }
  162|  9.08M|         (void)m( result );
  163|  9.08M|         return result;
  164|  9.08M|      }
  165|  9.08M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.08M|      {
   73|  9.08M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.08M|         else {
   84|  9.08M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.08M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.08M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.08M|      {
   44|  9.08M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.08M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.08M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.08M|      else {
  108|  9.08M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.08M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.08M|         constexpr bool has_apply_void = enable_action && internal::has_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.08M|         constexpr bool has_apply_bool = enable_action && internal::has_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.08M|         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.08M|         constexpr bool has_apply0_void = enable_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.08M|         constexpr bool has_apply0_bool = enable_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.08M|         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.08M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.08M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.08M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.08M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.08M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.08M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.08M|         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.08M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.08M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.08M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.08M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.08M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.7k, False: 8.99M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.7k|            else if constexpr( has_apply0_bool ) {
  153|  88.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.7k|            }
  155|  88.7k|         }
  156|  9.08M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.7k, False: 8.99M]
  ------------------
  157|  88.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.7k|         }
  159|  8.99M|         else {
  160|  8.99M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.99M|         }
  162|  9.08M|         (void)m( result );
  163|  9.08M|         return result;
  164|  9.08M|      }
  165|  9.08M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.08M|      {
   73|  9.08M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.08M|         else {
   84|  9.08M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.08M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.08M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.08M|      {
   59|  9.08M|         return Rule::match( in );
   60|  9.08M|      }
_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|  88.7k|   {
  104|  88.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  88.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|  88.7k|   }
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|  88.7k|      {
   44|  88.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.7k|      }
_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|  88.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.7k|      else {
  108|  88.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 88.6k, False: 105]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.6k|            else if constexpr( has_apply0_bool ) {
  153|  88.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.6k|            }
  155|  88.6k|         }
  156|  88.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.6k, False: 105]
  ------------------
  157|  88.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.6k|         }
  159|    105|         else {
  160|    105|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    105|         }
  162|  88.7k|         (void)m( result );
  163|  88.7k|         return result;
  164|  88.7k|      }
  165|  88.7k|   }
_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|  88.7k|      {
   73|  88.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|  88.7k|         else {
   84|  88.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.7k|      }
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|  88.7k|      {
   44|  88.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  88.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.7k|      else {
  108|  88.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.8k, False: 55.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|  32.8k|            else if constexpr( has_apply0_bool ) {
  153|  32.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.8k|            }
  155|  32.8k|         }
  156|  88.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.8k, False: 55.8k]
  ------------------
  157|  32.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.8k|         }
  159|  55.8k|         else {
  160|  55.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.8k|         }
  162|  88.7k|         (void)m( result );
  163|  88.7k|         return result;
  164|  88.7k|      }
  165|  88.7k|   }
_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|  88.7k|      {
   73|  88.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|  88.7k|         else {
   84|  88.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.7k|      }
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|  88.7k|      {
   44|  88.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  88.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  88.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.7k|      else {
  108|  88.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.9k, False: 55.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|  32.9k|            else if constexpr( has_apply0_bool ) {
  153|  32.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.9k|            }
  155|  32.9k|         }
  156|  88.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.9k, False: 55.7k]
  ------------------
  157|  32.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.9k|         }
  159|  55.7k|         else {
  160|  55.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.7k|         }
  162|  88.7k|         (void)m( result );
  163|  88.7k|         return result;
  164|  88.7k|      }
  165|  88.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  88.7k|      {
   73|  88.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|  88.7k|         else {
   84|  88.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.7k|      }
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|  88.7k|      {
   59|  88.7k|         return Rule::match( in );
   60|  88.7k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  32.9k|   {
  104|  32.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  32.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  32.9k|   }
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|  32.9k|      {
   44|  32.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.9k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  32.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  32.9k|      else {
  108|  32.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  32.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  32.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|  32.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|  32.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|  32.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|  32.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  32.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  32.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  32.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.8k, False: 47]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  32.8k|            else if constexpr( has_apply0_bool ) {
  153|  32.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.8k|            }
  155|  32.8k|         }
  156|  32.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.8k, False: 47]
  ------------------
  157|  32.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.8k|         }
  159|     47|         else {
  160|     47|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     47|         }
  162|  32.9k|         (void)m( result );
  163|  32.9k|         return result;
  164|  32.9k|      }
  165|  32.9k|   }
_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|  32.9k|      {
   73|  32.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|  32.9k|         else {
   84|  32.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  32.9k|      {
   44|  32.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  65.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  65.8k|      else {
  108|  65.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  65.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  65.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|  65.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|  65.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|  65.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|  65.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|  65.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|  65.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  65.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  65.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  65.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|  65.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  65.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  65.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|  65.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  65.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  65.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  65.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  65.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 65.7k, False: 47]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  65.7k|            else if constexpr( has_apply0_bool ) {
  153|  65.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  65.7k|            }
  155|  65.7k|         }
  156|  65.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 65.7k, False: 47]
  ------------------
  157|  65.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  65.7k|         }
  159|     47|         else {
  160|     47|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     47|         }
  162|  65.8k|         (void)m( result );
  163|  65.8k|         return result;
  164|  65.8k|      }
  165|  65.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  65.8k|      {
   73|  65.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|  65.8k|         else {
   84|  65.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  65.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  65.8k|      }
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|  65.8k|      {
   59|  65.8k|         return Rule::match( in );
   60|  65.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  55.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  55.7k|      else {
  108|  55.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  55.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  55.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|  55.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|  55.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|  55.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|  55.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|  55.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|  55.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  55.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  55.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  55.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|  55.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  55.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  55.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|  55.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  55.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  55.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  55.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  55.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.9k, False: 27.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|  27.9k|            else if constexpr( has_apply0_bool ) {
  153|  27.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.9k|            }
  155|  27.9k|         }
  156|  55.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.9k, False: 27.8k]
  ------------------
  157|  27.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.9k|         }
  159|  27.8k|         else {
  160|  27.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.8k|         }
  162|  55.7k|         (void)m( result );
  163|  55.7k|         return result;
  164|  55.7k|      }
  165|  55.7k|   }
_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|  55.7k|      {
   73|  55.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|  55.7k|         else {
   84|  55.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  55.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  55.7k|      }
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|  55.7k|      {
   44|  55.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  55.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  88.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  88.0k|      else {
  108|  88.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  88.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  88.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|  88.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|  88.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|  88.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|  88.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|  88.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|  88.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  88.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  88.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  88.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|  88.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  88.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  88.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|  88.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  88.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  88.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  88.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  88.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.8k, False: 53.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|  34.8k|            else if constexpr( has_apply0_bool ) {
  153|  34.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.8k|            }
  155|  34.8k|         }
  156|  88.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.8k, False: 53.1k]
  ------------------
  157|  34.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.8k|         }
  159|  53.1k|         else {
  160|  53.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  53.1k|         }
  162|  88.0k|         (void)m( result );
  163|  88.0k|         return result;
  164|  88.0k|      }
  165|  88.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  88.0k|      {
   73|  88.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|  88.0k|         else {
   84|  88.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  88.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  88.0k|      }
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|  88.0k|      {
   59|  88.0k|         return Rule::match( in );
   60|  88.0k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  27.9k|   {
  104|  27.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  27.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  27.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.9k|      {
   44|  27.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.9k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  27.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.9k|      else {
  108|  27.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.9k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  27.9k|            else if constexpr( has_apply0_bool ) {
  153|  27.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.9k|            }
  155|  27.9k|         }
  156|  27.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.9k, False: 0]
  ------------------
  157|  27.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  27.9k|         (void)m( result );
  163|  27.9k|         return result;
  164|  27.9k|      }
  165|  27.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  27.9k|      {
   73|  27.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|  27.9k|         else {
   84|  27.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.9k|      {
   44|  27.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  27.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.8k|      else {
  108|  27.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.1k, False: 1.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  26.1k|            else if constexpr( has_apply0_bool ) {
  153|  26.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.1k|            }
  155|  26.1k|         }
  156|  27.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.1k, False: 1.67k]
  ------------------
  157|  26.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.1k|         }
  159|  1.67k|         else {
  160|  1.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.67k|         }
  162|  27.8k|         (void)m( result );
  163|  27.8k|         return result;
  164|  27.8k|      }
  165|  27.8k|   }
_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|  27.8k|      {
   73|  27.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|  27.8k|         else {
   84|  27.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.8k|      }
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|  27.8k|      {
   59|  27.8k|         return Rule::match( in );
   60|  27.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.67k|      else {
  108|  1.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.61k, False: 58]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.61k|            else if constexpr( has_apply0_bool ) {
  153|  1.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.61k|            }
  155|  1.61k|         }
  156|  1.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.61k, False: 58]
  ------------------
  157|  1.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.61k|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|  1.67k|         (void)m( result );
  163|  1.67k|         return result;
  164|  1.67k|      }
  165|  1.67k|   }
_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.67k|      {
   73|  1.67k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.67k|         else {
   84|  1.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.67k|      {
   59|  1.67k|         return Rule::match( in );
   60|  1.67k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.99M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.99M|      else {
  108|  8.99M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.99M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.99M|         constexpr bool has_apply_void = enable_action && internal::has_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.99M|         constexpr bool has_apply_bool = enable_action && internal::has_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.99M|         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.99M|         constexpr bool has_apply0_void = enable_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.99M|         constexpr bool has_apply0_bool = enable_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.99M|         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.99M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.99M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.99M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.99M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.99M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.99M|         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.99M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.99M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.99M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.99M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.99M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.99M, False: 198]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.99M|            else if constexpr( has_apply0_bool ) {
  153|  8.99M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.99M|            }
  155|  8.99M|         }
  156|  8.99M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.99M, False: 198]
  ------------------
  157|  8.99M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.99M|         }
  159|    198|         else {
  160|    198|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    198|         }
  162|  8.99M|         (void)m( result );
  163|  8.99M|         return result;
  164|  8.99M|      }
  165|  8.99M|   }
_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.99M|      {
   73|  8.99M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99M|         else {
   84|  8.99M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.99M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.99M|      }
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.99M|      {
   59|  8.99M|         return Rule::match( in );
   60|  8.99M|      }
_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|  25.6k|   {
  104|  25.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  25.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|  25.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|  25.6k|      {
   44|  25.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.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|  28.7k|   {
  104|  28.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  28.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|  28.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.7k|      {
   44|  28.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.7k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  33.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.4k|      else {
  108|  33.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.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|  33.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|  33.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|  33.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|  33.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|  33.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|  33.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.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|  33.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.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|  33.4k|            else if constexpr( has_apply0_bool ) {
  153|  33.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.4k|            }
  155|  33.4k|         }
  156|  33.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.4k, False: 0]
  ------------------
  157|  33.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  33.4k|         (void)m( result );
  163|  33.4k|         return result;
  164|  33.4k|      }
  165|  33.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  33.4k|      {
   73|  33.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|  33.4k|         else {
   84|  33.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.4k|      {
   44|  33.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.4k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  33.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.5k|      else {
  108|  33.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.0k, False: 4.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|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|  33.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 4.53k]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|  4.53k|         else {
  160|  4.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.53k|         }
  162|  33.5k|         (void)m( result );
  163|  33.5k|         return result;
  164|  33.5k|      }
  165|  33.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  33.5k|      {
   73|  33.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.5k|         else {
   84|  33.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.5k|      {
   44|  33.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.5k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  33.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.5k|      else {
  108|  33.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.0k, False: 4.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|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|  33.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 4.53k]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|  4.53k|         else {
  160|  4.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.53k|         }
  162|  33.5k|         (void)m( result );
  163|  33.5k|         return result;
  164|  33.5k|      }
  165|  33.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
   72|  33.5k|      {
   73|  33.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.5k|         else {
   84|  33.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  33.5k|      {
   59|  33.5k|         return Rule::match( in );
   60|  33.5k|      }

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

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   190k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   244k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   244k|         else {
   92|   244k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   244k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   244k|         }
   94|   244k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  6.00M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  3.66M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.34M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   190k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  38.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.1k|         else {
   92|  38.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.1k|         }
   94|  38.1k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  38.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.1k|         else {
   92|  38.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.1k|         }
   94|  38.1k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  71.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|  71.6k|         else {
   92|  71.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  71.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  71.6k|         }
   94|  71.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  71.6k|      {}
_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|  71.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|  71.6k|         else {
   92|  71.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  71.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  71.6k|         }
   94|  71.6k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  71.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  71.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|  71.6k|         else {
   92|  71.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  71.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  71.6k|         }
   94|  71.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  71.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.2k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSF_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   331k|      {}
_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|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   331k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   364k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  39.3k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   325k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   320k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   320k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   320k|         else {
   92|   320k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   320k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   320k|         }
   94|   320k|      }
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   320k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   320k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   320k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0ITtTpTyENS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  10.3k|      {
   75|  10.3k|         return Action< Rule >::apply0( st... );
   76|  10.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  61.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  34.3k|      {}
_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.70k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.10k|      {}
_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.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.10k|         else {
   92|  1.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.10k|         }
   94|  1.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.10k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     14|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.09k|      {}
_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.09k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.09k|         else {
   92|  1.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.09k|         }
   94|  1.09k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    946|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    147|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    147|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    147|         else {
   92|    147|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    147|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    147|         }
   94|    147|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    147|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     44|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    103|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5applyITtTpTyENS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  38.0k|      {
   65|  38.0k|         const typename ParseInput::action_t action_input( begin, in );
   66|  38.0k|         return Action< Rule >::apply( action_input, st... );
   67|  38.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    103|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  38.0k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.15M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_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_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.11M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  43.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   892k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.5k|         else {
   92|  40.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.5k|         }
   94|  40.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.74M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  49.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|  49.6k|         else {
   92|  49.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  49.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  49.6k|         }
   94|  49.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.27M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.37M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.90M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.74M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.5k|         else {
   92|  37.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.5k|         }
   94|  37.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.90M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.86M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   855k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.18M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.18M|      {}
_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|  2.51k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.51k|         else {
   92|  2.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.51k|         }
   94|  2.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   855k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   855k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     27|      {}
_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|  2.50k|      {
   65|  2.50k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.50k|         return Action< Rule >::apply( action_input, st... );
   67|  2.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.5k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  38.0k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  38.0k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_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|  35.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|  35.9k|         else {
   92|  35.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.9k|         }
   94|  35.9k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  35.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.6k|         else {
   92|  40.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.6k|         }
   94|  40.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.6k|         else {
   92|  40.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.6k|         }
   94|  40.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.6k|      {}
_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|  40.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|  40.6k|         else {
   92|  40.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.6k|         }
   94|  40.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.6k|         else {
   92|  40.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.6k|         }
   94|  40.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.6k|      {}
_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.45k|      {
   65|  3.45k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.45k|         return Action< Rule >::apply( action_input, st... );
   67|  3.45k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.44k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   856k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   856k|         else {
   92|   856k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   856k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   856k|         }
   94|   856k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   856k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   856k|         else {
   92|   856k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   856k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   856k|         }
   94|   856k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   869k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   869k|         else {
   92|   869k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   869k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   869k|         }
   94|   869k|      }
_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.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.42k|      {}
_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.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.42k|      {}
_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.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_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.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_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.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.95k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.2k|      {}
_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.20k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.20k|         else {
   92|  3.20k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.20k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.20k|         }
   94|  3.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.98k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.98k|         else {
   92|  2.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.98k|         }
   94|  2.98k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.50k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.76k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.76k|         else {
   92|  2.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.76k|         }
   94|  2.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.24k|         else {
   92|  2.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.24k|         }
   94|  2.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.97k|         else {
   92|  1.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.97k|         }
   94|  1.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.8k|      {}
_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|  15.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.8k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  37.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  37.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  24.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  12.3k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.43k|         else {
   92|  4.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.43k|         }
   94|  4.43k|      }
_ZN3tao5pegtl6normalINS0_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.25k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.25k|         else {
   92|  2.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.25k|         }
   94|  2.25k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.25k|      {}
_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.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|  2.18k|         else {
   92|  2.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.18k|         }
   94|  2.18k|      }
_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|   851k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   851k|         else {
   92|   851k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   851k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   851k|         }
   94|   851k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.18k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     71|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.18k|         else {
   92|  2.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.18k|         }
   94|  2.18k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  22.9k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  21.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.80k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.02k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   854k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   854k|         else {
   92|   854k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   854k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   854k|         }
   94|   854k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   854k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   854k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   854k|         else {
   92|   854k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   854k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   854k|         }
   94|   854k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.70M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.70M|         else {
   92|  1.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.70M|         }
   94|  1.70M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.71M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.71M|         else {
   92|  1.71M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.71M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.71M|         }
   94|  1.71M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.70M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.70M|         else {
   92|  1.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.70M|         }
   94|  1.70M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   852k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   852k|         else {
   92|   852k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   852k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   852k|         }
   94|   852k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   852k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   852k|         else {
   92|   852k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   852k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   852k|         }
   94|   852k|      }
_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|   852k|      {
   65|   852k|         const typename ParseInput::action_t action_input( begin, in );
   66|   852k|         return Action< Rule >::apply( action_input, st... );
   67|   852k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   852k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.66k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    452|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_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|  37.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  37.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.67k|      {
   65|  3.67k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.67k|         return Action< Rule >::apply( action_input, st... );
   67|  3.67k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.67k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.0k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   320k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   320k|         else {
   92|   320k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   320k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   320k|         }
   94|   320k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   320k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   320k|         else {
   92|   320k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   320k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   320k|         }
   94|   320k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   328k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   328k|         else {
   92|   328k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   328k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   328k|         }
   94|   328k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  24.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.3k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|      }
_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.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|      }
_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.76k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.76k|         else {
   92|  2.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.76k|         }
   94|  2.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_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|      }
_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.17k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.17k|         else {
   92|  2.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.17k|         }
   94|  2.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.68k|      {
   65|  1.68k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.68k|         return Action< Rule >::apply( action_input, st... );
   67|  1.68k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.91k|         else {
   92|  4.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.91k|         }
   94|  4.91k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.49k|         else {
   92|  2.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.49k|         }
   94|  2.49k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  16.1k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.44k|         else {
   92|  2.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.44k|         }
   94|  2.44k|      }
_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|   315k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   315k|         else {
   92|   315k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   315k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   315k|         }
   94|   315k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  15.6k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    289|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_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_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  14.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.29k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   317k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   317k|         else {
   92|   317k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   317k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   317k|         }
   94|   317k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   357k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   317k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   317k|         else {
   92|   317k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   317k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   317k|         }
   94|   317k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  59.2M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   711k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  58.5M|      {}
_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|   316k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   316k|         else {
   92|   316k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   316k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   316k|         }
   94|   316k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   316k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   316k|         else {
   92|   316k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   316k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   316k|         }
   94|   316k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   351k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.9M|         else {
   92|  15.9M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.9M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.9M|         }
   94|  15.9M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.6M|         else {
   92|  15.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6M|         }
   94|  15.6M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  58.5M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.6M|         else {
   92|  15.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6M|         }
   94|  15.6M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  58.5M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.6M|         else {
   92|  15.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6M|         }
   94|  15.6M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   103M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   967k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   102M|      {}
_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|   239k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   239k|         else {
   92|   239k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   239k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   239k|         }
   94|   239k|      }
_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|   239k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   239k|         else {
   92|   239k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   239k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   239k|         }
   94|   239k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   781k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   239k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   239k|         else {
   92|   239k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   239k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   239k|         }
   94|   239k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   967k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   239k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   239k|         else {
   92|   239k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   239k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   239k|         }
   94|   239k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   967k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   345k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   621k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   345k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   212k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   212k|         else {
   92|   212k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   212k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   212k|         }
   94|   212k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   345k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    279|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    279|      {
   49|    279|#if defined( __cpp_exceptions )
   50|    279|         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|    279|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   345k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   621k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   133k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   133k|         else {
   92|   133k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   133k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   133k|         }
   94|   133k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   621k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   173k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   173k|         else {
   92|   173k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   173k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   173k|         }
   94|   173k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   874k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   275k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   598k|      {}
_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|  34.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|  34.9k|         else {
   92|  34.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.9k|         }
   94|  34.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  34.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|  34.9k|         else {
   92|  34.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.9k|         }
   94|  34.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   213k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   213k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   213k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   408k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  98.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|  98.5k|         else {
   92|  98.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  98.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  98.5k|         }
   94|  98.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   408k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   397k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.37k|      {
   88|       |         if constexpr( internal::has_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.37k|         else {
   92|  4.37k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.37k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.37k|         }
   94|  4.37k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   780k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    359|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    359|      {
   49|    359|#if defined( __cpp_exceptions )
   50|    359|         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|    359|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   780k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  57.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.3M|         else {
   92|  15.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.3M|         }
   94|  15.3M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   102M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   102M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.57k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  58.5M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.30k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   349k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.30k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.30k|      {
   49|  1.30k|#if defined( __cpp_exceptions )
   50|  1.30k|         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.30k|      }
_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|   315k|      {
   65|   315k|         const typename ParseInput::action_t action_input( begin, in );
   66|   315k|         return Action< Rule >::apply( action_input, st... );
   67|   315k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   348k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.69k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  19.8k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.19k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.94k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.94k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  34.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|  34.3k|         else {
   92|  34.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.3k|         }
   94|  34.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.3k|      {}
_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|  34.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|  34.3k|         else {
   92|  34.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.3k|         }
   94|  34.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  34.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|  34.3k|         else {
   92|  34.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.3k|         }
   94|  34.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  34.3k|      {}
_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.17k|      {
   65|  4.17k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.17k|         return Action< Rule >::apply( action_input, st... );
   67|  4.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.9k|         else {
   92|  11.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9k|         }
   94|  11.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.9k|         else {
   92|  11.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.9k|         }
   94|  11.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  20.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|  20.5k|         else {
   92|  20.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.5k|         }
   94|  20.5k|      }
_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.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_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.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_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.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_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.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_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.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_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.93k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.93k|         else {
   92|  3.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.93k|         }
   94|  3.93k|      }
_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.59k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.59k|         else {
   92|  3.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.59k|         }
   94|  3.59k|      }
_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.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.38k|         else {
   92|  3.38k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.38k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.38k|         }
   94|  3.38k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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|      }
_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.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_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.47k|      {
   65|  1.47k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.47k|         return Action< Rule >::apply( action_input, st... );
   67|  1.47k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.14k|         else {
   92|  4.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.14k|         }
   94|  4.14k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_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.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|  2.80k|         else {
   92|  2.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.80k|         }
   94|  2.80k|      }
_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.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|  2.73k|         else {
   92|  2.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.73k|         }
   94|  2.73k|      }
_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.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|  6.33k|         else {
   92|  6.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.33k|         }
   94|  6.33k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.78k|         else {
   92|  8.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.78k|         }
   94|  8.78k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.78k|         else {
   92|  8.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.78k|         }
   94|  8.78k|      }
_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.54k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.54k|         else {
   92|  7.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.54k|         }
   94|  7.54k|      }
_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.54k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.54k|         else {
   92|  7.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.54k|         }
   94|  7.54k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.28M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.28M|         else {
   92|  9.28M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.28M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.28M|         }
   94|  9.28M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.27M|      {
   88|       |         if constexpr( internal::has_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.27M|         else {
   92|  9.27M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.27M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.27M|         }
   94|  9.27M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.27M|      {
   88|       |         if constexpr( internal::has_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.27M|         else {
   92|  9.27M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.27M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.27M|         }
   94|  9.27M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.27M|      {
   88|       |         if constexpr( internal::has_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.27M|         else {
   92|  9.27M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.27M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.27M|         }
   94|  9.27M|      }
_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|   127k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   127k|         else {
   92|   127k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   127k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   127k|         }
   94|   127k|      }
_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|   127k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   127k|         else {
   92|   127k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   127k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   127k|         }
   94|   127k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   127k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   127k|         else {
   92|   127k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   127k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   127k|         }
   94|   127k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   127k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   127k|         else {
   92|   127k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   127k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   127k|         }
   94|   127k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_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_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  82.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|  82.0k|         else {
   92|  82.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  82.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  82.0k|         }
   94|  82.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  86.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|  86.5k|         else {
   92|  86.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.5k|         }
   94|  86.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   135k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   135k|         else {
   92|   135k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   135k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   135k|         }
   94|   135k|      }
_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|  43.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|  43.5k|         else {
   92|  43.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.5k|         }
   94|  43.5k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.5k|         else {
   92|  43.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.5k|         }
   94|  43.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  42.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.9k|         else {
   92|  42.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.9k|         }
   94|  42.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    696|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    696|         else {
   92|    696|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    696|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    696|         }
   94|    696|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.14M|      {
   88|       |         if constexpr( internal::has_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.14M|         else {
   92|  9.14M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.14M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.14M|         }
   94|  9.14M|      }
_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.24k|      {
   65|  7.24k|         const typename ParseInput::action_t action_input( begin, in );
   66|  7.24k|         return Action< Rule >::apply( action_input, st... );
   67|  7.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.5k|      {}
_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|  30.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.5k|      {}
_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|  30.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.5k|      {}
_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|  30.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.5k|      {}
_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.23k|      {
   65|  3.23k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.23k|         return Action< Rule >::apply( action_input, st... );
   67|  3.23k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.22k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.3k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  10.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.0k|         else {
   92|  10.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.0k|         }
   94|  10.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.0k|         else {
   92|  10.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.0k|         }
   94|  10.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.8k|         else {
   92|  16.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.8k|         }
   94|  16.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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|      }
_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.79k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.79k|         else {
   92|  2.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.79k|         }
   94|  2.79k|      }
_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.59k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.59k|         else {
   92|  2.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.59k|         }
   94|  2.59k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.40k|         else {
   92|  2.40k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.40k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.40k|         }
   94|  2.40k|      }
_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.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|      }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.26k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.26k|         else {
   92|  4.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.26k|         }
   94|  4.26k|      }
_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.17k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.17k|         else {
   92|  2.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.17k|         }
   94|  2.17k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.11k|         else {
   92|  2.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.11k|         }
   94|  2.11k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.52k|         else {
   92|  5.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.52k|         }
   94|  5.52k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.09k|         else {
   92|  2.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.09k|         }
   94|  2.09k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.55k|         else {
   92|  7.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.55k|         }
   94|  7.55k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.55k|         else {
   92|  7.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.55k|         }
   94|  7.55k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.45k|         else {
   92|  6.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.45k|         }
   94|  6.45k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.45k|         else {
   92|  6.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.45k|         }
   94|  6.45k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.83M|         else {
   92|  7.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.83M|         }
   94|  7.83M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.83M|         else {
   92|  7.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.83M|         }
   94|  7.83M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.83M|         else {
   92|  7.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.83M|         }
   94|  7.83M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.83M|         else {
   92|  7.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.83M|         }
   94|  7.83M|      }
_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|   161k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   161k|         else {
   92|   161k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   161k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   161k|         }
   94|   161k|      }
_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|   161k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   161k|         else {
   92|   161k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   161k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   161k|         }
   94|   161k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   161k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   161k|         else {
   92|   161k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   161k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   161k|         }
   94|   161k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   161k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   161k|         else {
   92|   161k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   161k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   161k|         }
   94|   161k|      }
_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|  74.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|  74.6k|         else {
   92|  74.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  74.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  74.6k|         }
   94|  74.6k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  74.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|  74.6k|         else {
   92|  74.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  74.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  74.6k|         }
   94|  74.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   149k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   149k|         else {
   92|   149k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   149k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   149k|         }
   94|   149k|      }
_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.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|  86.9k|         else {
   92|  86.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  86.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  86.9k|         }
   94|  86.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   121k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   121k|         else {
   92|   121k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   121k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   121k|         }
   94|   121k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  26.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|  26.0k|         else {
   92|  26.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.0k|         }
   94|  26.0k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  26.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|  26.0k|         else {
   92|  26.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.0k|         }
   94|  26.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  60.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|  60.9k|         else {
   92|  60.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  60.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  60.9k|         }
   94|  60.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.25k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.25k|         else {
   92|  2.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.25k|         }
   94|  2.25k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.67M|         else {
   92|  7.67M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.67M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.67M|         }
   94|  7.67M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  6.19k|      {
   65|  6.19k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.19k|         return Action< Rule >::apply( action_input, st... );
   67|  6.19k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.58k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.58k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.6k|         else {
   92|  27.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.6k|         }
   94|  27.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.6k|      {}
_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|  27.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|  27.6k|         else {
   92|  27.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.6k|         }
   94|  27.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.6k|         else {
   92|  27.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.6k|         }
   94|  27.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.6k|      {}
_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.01k|      {
   65|  3.01k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.01k|         return Action< Rule >::apply( action_input, st... );
   67|  3.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.00k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.39k|         else {
   92|  8.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.39k|         }
   94|  8.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.39k|         else {
   92|  8.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.39k|         }
   94|  8.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.0k|         else {
   92|  16.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.0k|         }
   94|  16.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_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.77k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.77k|         else {
   92|  2.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.77k|         }
   94|  2.77k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.56k|         else {
   92|  2.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.56k|         }
   94|  2.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.37k|      {
   88|       |         if constexpr( internal::has_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.37k|         else {
   92|  2.37k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.37k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.37k|         }
   94|  2.37k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.30k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.30k|         else {
   92|  2.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.30k|         }
   94|  2.30k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.97k|         else {
   92|  1.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.97k|         }
   94|  1.97k|      }
_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.60k|      {
   65|  1.60k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.60k|         return Action< Rule >::apply( action_input, st... );
   67|  1.60k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.78k|         else {
   92|  3.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.78k|         }
   94|  3.78k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  1.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.91k|         else {
   92|  1.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91k|         }
   94|  1.91k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.88k|         else {
   92|  1.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.88k|         }
   94|  1.88k|      }
_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.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.78k|         else {
   92|  3.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.78k|         }
   94|  3.78k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.87k|         else {
   92|  1.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.87k|         }
   94|  1.87k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_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_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.77k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.77k|         else {
   92|  4.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.77k|         }
   94|  4.77k|      }
_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.77k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.77k|         else {
   92|  4.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.77k|         }
   94|  4.77k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.46M|         else {
   92|  2.46M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.46M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.46M|         }
   94|  2.46M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.45M|      {
   88|       |         if constexpr( internal::has_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.45M|         else {
   92|  2.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45M|         }
   94|  2.45M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.45M|      {
   88|       |         if constexpr( internal::has_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.45M|         else {
   92|  2.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45M|         }
   94|  2.45M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.45M|      {
   88|       |         if constexpr( internal::has_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.45M|         else {
   92|  2.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45M|         }
   94|  2.45M|      }
_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|  5.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|  5.33k|         else {
   92|  5.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.33k|         }
   94|  5.33k|      }
_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|  5.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|  5.33k|         else {
   92|  5.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.33k|         }
   94|  5.33k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.33k|         else {
   92|  5.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.33k|         }
   94|  5.33k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.33k|         else {
   92|  5.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.33k|         }
   94|  5.33k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.52k|         else {
   92|  1.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.52k|         }
   94|  1.52k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.52k|         else {
   92|  1.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.52k|         }
   94|  1.52k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.80k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.80k|         else {
   92|  3.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.80k|         }
   94|  3.80k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.26k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.26k|         else {
   92|  5.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.26k|         }
   94|  5.26k|      }
_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.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|  1.04k|         else {
   92|  1.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.04k|         }
   94|  1.04k|      }
_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.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|  1.04k|         else {
   92|  1.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.04k|         }
   94|  1.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.76k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.76k|         else {
   92|  2.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.76k|         }
   94|  2.76k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    236|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    236|         else {
   92|    236|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    236|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    236|         }
   94|    236|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.45M|      {
   88|       |         if constexpr( internal::has_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.45M|         else {
   92|  2.45M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45M|         }
   94|  2.45M|      }
_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.56k|      {
   65|  4.56k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.56k|         return Action< Rule >::apply( action_input, st... );
   67|  4.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.53k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.53k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.9k|      {}
_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|  24.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|  24.9k|         else {
   92|  24.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.9k|         }
   94|  24.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.9k|      {}
_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|  24.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|  24.9k|         else {
   92|  24.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.9k|         }
   94|  24.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.9k|      {}
_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|  24.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|  24.9k|         else {
   92|  24.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.9k|         }
   94|  24.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.9k|      {}
_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.23k|      {
   65|  3.23k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.23k|         return Action< Rule >::apply( action_input, st... );
   67|  3.23k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.22k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.6k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.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_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_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_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  17.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|  17.0k|         else {
   92|  17.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.0k|         }
   94|  17.0k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_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.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.13k|         else {
   92|  3.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.13k|         }
   94|  3.13k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.90k|         else {
   92|  2.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.90k|         }
   94|  2.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.45k|         else {
   92|  2.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.45k|         }
   94|  2.45k|      }
_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.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|  2.18k|         else {
   92|  2.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.18k|         }
   94|  2.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.22k|      {
   65|  1.22k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.22k|         return Action< Rule >::apply( action_input, st... );
   67|  1.22k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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_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.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.12k|         else {
   92|  2.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.12k|         }
   94|  2.12k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.44k|         else {
   92|  4.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.44k|         }
   94|  4.44k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.05k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.05k|         else {
   92|  2.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.05k|         }
   94|  2.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.45k|         else {
   92|  6.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.45k|         }
   94|  6.45k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.45k|         else {
   92|  6.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.45k|         }
   94|  6.45k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.39k|         else {
   92|  5.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.39k|         }
   94|  5.39k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.39k|         else {
   92|  5.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.39k|         }
   94|  5.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.50M|         else {
   92|  6.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50M|         }
   94|  6.50M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.50M|         else {
   92|  6.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50M|         }
   94|  6.50M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.50M|         else {
   92|  6.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50M|         }
   94|  6.50M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.50M|         else {
   92|  6.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.50M|         }
   94|  6.50M|      }
_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|  69.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|  69.8k|         else {
   92|  69.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  69.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  69.8k|         }
   94|  69.8k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  69.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|  69.8k|         else {
   92|  69.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  69.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  69.8k|         }
   94|  69.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  69.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|  69.8k|         else {
   92|  69.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  69.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  69.8k|         }
   94|  69.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  69.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|  69.8k|         else {
   92|  69.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  69.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  69.8k|         }
   94|  69.8k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  30.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  30.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  61.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|  61.0k|         else {
   92|  61.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  61.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  61.0k|         }
   94|  61.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  39.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|  39.3k|         else {
   92|  39.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.3k|         }
   94|  39.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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_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|  14.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|  14.9k|         else {
   92|  14.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.9k|         }
   94|  14.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.9k|         else {
   92|  14.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.9k|         }
   94|  14.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  24.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|  24.4k|         else {
   92|  24.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.4k|         }
   94|  24.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    437|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    437|         else {
   92|    437|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    437|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    437|         }
   94|    437|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.43M|         else {
   92|  6.43M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.43M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.43M|         }
   94|  6.43M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.10k|      {
   65|  5.10k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.10k|         return Action< Rule >::apply( action_input, st... );
   67|  5.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.54k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.54k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.0k|      {}
_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.46k|      {
   65|  3.46k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.46k|         return Action< Rule >::apply( action_input, st... );
   67|  3.46k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.46k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.5k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   168k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   168k|         else {
   92|   168k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   168k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   168k|         }
   94|   168k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   168k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   168k|         else {
   92|   168k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   168k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   168k|         }
   94|   168k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.62M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.62M|         else {
   92|  1.62M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.62M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.62M|         }
   94|  1.62M|      }
_ZN3tao5pegtl6normalINS0_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.45k|      {}
_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.45k|      {}
_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_ZN3tao5pegtl6normalINS0_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_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.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_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.20k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.20k|         else {
   92|  3.20k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.20k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.20k|         }
   94|  3.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.99k|         else {
   92|  2.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.99k|         }
   94|  2.99k|      }
_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.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.65k|         else {
   92|  2.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.65k|         }
   94|  2.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.36k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.36k|         else {
   92|  2.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.36k|         }
   94|  2.36k|      }
_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.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.87k|         else {
   92|  1.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.87k|         }
   94|  1.87k|      }
_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.05k|      {
   65|  2.05k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.05k|         return Action< Rule >::apply( action_input, st... );
   67|  2.05k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.45k|         else {
   92|  3.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.45k|         }
   94|  3.45k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.15k|         else {
   92|  5.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.15k|         }
   94|  5.15k|      }
_ZN3tao5pegtl6normalINS0_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.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_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.60k|      {}
_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.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|      }
_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|   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_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.55k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     49|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.36k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   165k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   493k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   826k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   826k|         else {
   92|   826k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   826k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   826k|         }
   94|   826k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   333k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   160k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   328k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   328k|         else {
   92|   328k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   328k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   328k|         }
   94|   328k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   327k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   327k|         else {
   92|   327k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   327k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   327k|         }
   94|   327k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   327k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   327k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   327k|         else {
   92|   327k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   327k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   327k|         }
   94|   327k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   158k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   158k|         else {
   92|   158k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   158k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   158k|         }
   94|   158k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   327k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     49|      {}
_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.22k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.99k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    456|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5applyITtTpTyENS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.76k|      {
   65|  2.76k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.76k|         return Action< Rule >::apply( action_input, st... );
   67|  2.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.13k|         else {
   92|  8.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.13k|         }
   94|  8.13k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.13k|         else {
   92|  8.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.13k|         }
   94|  8.13k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.4k|         else {
   92|  16.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.4k|         }
   94|  16.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.74k|         else {
   92|  2.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.74k|         }
   94|  2.74k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.74k|         else {
   92|  2.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.74k|         }
   94|  2.74k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|      }
_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.54k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.54k|         else {
   92|  2.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.54k|         }
   94|  2.54k|      }
_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.32k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.32k|         else {
   92|  2.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.32k|         }
   94|  2.32k|      }
_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.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.13k|         else {
   92|  2.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.13k|         }
   94|  2.13k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.90k|         else {
   92|  1.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.90k|         }
   94|  1.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.71k|         else {
   92|  1.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.71k|         }
   94|  1.71k|      }
_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.24k|      {
   65|  1.24k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.24k|         return Action< Rule >::apply( action_input, st... );
   67|  1.24k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.74k|         else {
   92|  2.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.74k|         }
   94|  2.74k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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_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.05k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.05k|         else {
   92|  2.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.05k|         }
   94|  2.05k|      }
_ZN3tao5pegtl6normalINS0_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|  1.99k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.99k|         else {
   92|  1.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.99k|         }
   94|  1.99k|      }
_ZN3tao5pegtl6normalINS0_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.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|  4.13k|         else {
   92|  4.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.13k|         }
   94|  4.13k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.98k|         else {
   92|  1.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.98k|         }
   94|  1.98k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.54k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.54k|         else {
   92|  5.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.54k|         }
   94|  5.54k|      }
_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.54k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.54k|         else {
   92|  5.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.54k|         }
   94|  5.54k|      }
_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|  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_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|  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_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.81M|      {
   88|       |         if constexpr( internal::has_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.81M|         else {
   92|  7.81M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.81M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.81M|         }
   94|  7.81M|      }
_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.80M|      {
   88|       |         if constexpr( internal::has_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.80M|         else {
   92|  7.80M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.80M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.80M|         }
   94|  7.80M|      }
_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.80M|      {
   88|       |         if constexpr( internal::has_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.80M|         else {
   92|  7.80M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.80M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.80M|         }
   94|  7.80M|      }
_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.80M|      {
   88|       |         if constexpr( internal::has_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.80M|         else {
   92|  7.80M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.80M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.80M|         }
   94|  7.80M|      }
_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|  88.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|  88.2k|         else {
   92|  88.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.2k|         }
   94|  88.2k|      }
_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|  88.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|  88.2k|         else {
   92|  88.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.2k|         }
   94|  88.2k|      }
_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|  88.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|  88.2k|         else {
   92|  88.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.2k|         }
   94|  88.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  88.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|  88.2k|         else {
   92|  88.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.2k|         }
   94|  88.2k|      }
_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|  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_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  41.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|  41.5k|         else {
   92|  41.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.5k|         }
   94|  41.5k|      }
_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|  67.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|  67.4k|         else {
   92|  67.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  67.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  67.4k|         }
   94|  67.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|   100k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   100k|         else {
   92|   100k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   100k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   100k|         }
   94|   100k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_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|  28.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|  28.9k|         else {
   92|  28.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.9k|         }
   94|  28.9k|      }
_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|  28.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|  28.9k|         else {
   92|  28.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.9k|         }
   94|  28.9k|      }
_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|  38.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|  38.5k|         else {
   92|  38.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.5k|         }
   94|  38.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.24k|         else {
   92|  1.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.24k|         }
   94|  1.24k|      }
_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.71M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.71M|         else {
   92|  7.71M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.71M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.71M|         }
   94|  7.71M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_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.49k|      {
   65|  4.49k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.49k|         return Action< Rule >::apply( action_input, st... );
   67|  4.49k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.17k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.17k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.5k|         else {
   92|  16.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.5k|         }
   94|  16.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.5k|         else {
   92|  16.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.5k|         }
   94|  16.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.5k|         else {
   92|  16.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.5k|         }
   94|  16.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.5k|      {}
_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.00k|      {
   65|  6.00k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.00k|         return Action< Rule >::apply( action_input, st... );
   67|  6.00k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  5.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.5k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   645k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   645k|         else {
   92|   645k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   645k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   645k|         }
   94|   645k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   645k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   645k|         else {
   92|   645k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   645k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   645k|         }
   94|   645k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   681k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   681k|         else {
   92|   681k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   681k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   681k|         }
   94|   681k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  5.97k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  5.97k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.86k|         else {
   92|  5.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.86k|         }
   94|  5.86k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.64k|         else {
   92|  5.64k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.64k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.64k|         }
   94|  5.64k|      }
_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.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.43k|         else {
   92|  5.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.43k|         }
   94|  5.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.12k|         else {
   92|  5.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.12k|         }
   94|  5.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|      }
_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.32k|      {
   65|  1.32k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.32k|         return Action< Rule >::apply( action_input, st... );
   67|  1.32k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.97k|         else {
   92|  5.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.97k|         }
   94|  5.97k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.27k|         else {
   92|  6.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.27k|         }
   94|  6.27k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.75k|      {
   88|       |         if constexpr( internal::has_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.75k|         else {
   92|  3.75k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.75k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.75k|         }
   94|  3.75k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.75k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.61k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.61k|         else {
   92|  3.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.61k|         }
   94|  3.61k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   638k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   638k|         else {
   92|   638k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   638k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   638k|         }
   94|   638k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.52k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     39|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.92k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.86k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   643k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   643k|         else {
   92|   643k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   643k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   643k|         }
   94|   643k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   643k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   643k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   643k|         else {
   92|   643k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   643k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   643k|         }
   94|   643k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   643k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   643k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   643k|         else {
   92|   643k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   643k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   643k|         }
   94|   643k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   643k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    498|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   642k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   643k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   643k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   643k|         else {
   92|   643k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   643k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   643k|         }
   94|   643k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   643k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   643k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   643k|         else {
   92|   643k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   643k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   643k|         }
   94|   643k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   643k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.29k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  29.4M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.4M|         else {
   92|  29.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.4M|         }
   94|  29.4M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  29.4M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  28.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   641k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.29k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  36.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   605k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  36.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|  36.1k|         else {
   92|  36.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.1k|         }
   94|  36.1k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  36.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|  36.1k|         else {
   92|  36.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.1k|         }
   94|  36.1k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  36.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.0M|         else {
   92|  45.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0M|         }
   94|  45.0M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  45.0M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  36.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  45.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.0M|         else {
   92|  45.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0M|         }
   94|  45.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.0M|         else {
   92|  45.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0M|         }
   94|  45.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  45.0M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.0M|         else {
   92|  45.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.0M|         }
   94|  45.0M|      }
_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|   186k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   186k|         else {
   92|   186k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   186k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   186k|         }
   94|   186k|      }
_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|   186k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   186k|         else {
   92|   186k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   186k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   186k|         }
   94|   186k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   186k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   186k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   186k|         else {
   92|   186k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   186k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   186k|         }
   94|   186k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   186k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   186k|         else {
   92|   186k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   186k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   186k|         }
   94|   186k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.0k|         else {
   92|  38.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.0k|         }
   94|  38.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  75.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|  75.9k|         else {
   92|  75.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.9k|         }
   94|  75.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   148k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   148k|         else {
   92|   148k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   148k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   148k|         }
   94|   148k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   192k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  36.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  36.0k|         else {
   92|  36.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.0k|         }
   94|  36.0k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  36.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  36.0k|         else {
   92|  36.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.0k|         }
   94|  36.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   112k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   112k|         else {
   92|   112k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   112k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   112k|         }
   94|   112k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    491|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    491|         else {
   92|    491|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    491|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    491|         }
   94|    491|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   186k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     61|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     61|      {
   49|     61|#if defined( __cpp_exceptions )
   50|     61|         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|     61|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   186k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.8M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.8M|         else {
   92|  44.8M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.8M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.8M|         }
   94|  44.8M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  45.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    270|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  35.7k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    270|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    270|      {
   49|    270|#if defined( __cpp_exceptions )
   50|    270|         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|    270|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  35.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   605k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   641k|      {
   65|   641k|         const typename ParseInput::action_t action_input( begin, in );
   66|   641k|         return Action< Rule >::apply( action_input, st... );
   67|   641k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   639k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.29k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.95k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    714|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.95k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.95k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.3k|         else {
   92|  11.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.3k|         }
   94|  11.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.3k|         else {
   92|  11.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.3k|         }
   94|  11.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.3k|         else {
   92|  11.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.3k|         }
   94|  11.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.36k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.94k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_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_modeE0ETtTpTyEN8usbguard10RuleParser13label_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_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  17.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|  17.1k|         else {
   92|  17.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.1k|         }
   94|  17.1k|      }
_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.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_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.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_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.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_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_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.76k|      {
   65|  1.76k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.76k|         return Action< Rule >::apply( action_input, st... );
   67|  1.76k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.34k|         else {
   92|  4.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.34k|         }
   94|  4.34k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.12k|         else {
   92|  5.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.12k|         }
   94|  5.12k|      }
_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.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_13label_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_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.63k|         else {
   92|  4.63k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.63k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.63k|         }
   94|  4.63k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.51k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.51k|         else {
   92|  2.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.51k|         }
   94|  2.51k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.08k|         else {
   92|  7.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.08k|         }
   94|  7.08k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.08k|         else {
   92|  7.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.08k|         }
   94|  7.08k|      }
_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.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|  6.24k|         else {
   92|  6.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.24k|         }
   94|  6.24k|      }
_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.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|  6.24k|         else {
   92|  6.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.24k|         }
   94|  6.24k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.08M|      {
   88|       |         if constexpr( internal::has_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.08M|         else {
   92|  9.08M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.08M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.08M|         }
   94|  9.08M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.08M|      {
   88|       |         if constexpr( internal::has_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.08M|         else {
   92|  9.08M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.08M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.08M|         }
   94|  9.08M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.08M|      {
   88|       |         if constexpr( internal::has_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.08M|         else {
   92|  9.08M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.08M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.08M|         }
   94|  9.08M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.08M|      {
   88|       |         if constexpr( internal::has_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.08M|         else {
   92|  9.08M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.08M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.08M|         }
   94|  9.08M|      }
_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|  88.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|  88.7k|         else {
   92|  88.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.7k|         }
   94|  88.7k|      }
_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|  88.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|  88.7k|         else {
   92|  88.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.7k|         }
   94|  88.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  88.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|  88.7k|         else {
   92|  88.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.7k|         }
   94|  88.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  88.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|  88.7k|         else {
   92|  88.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.7k|         }
   94|  88.7k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  32.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|  32.9k|         else {
   92|  32.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.9k|         }
   94|  32.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  32.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|  32.9k|         else {
   92|  32.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.9k|         }
   94|  32.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  65.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|  65.8k|         else {
   92|  65.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  65.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  65.8k|         }
   94|  65.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  55.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|  55.7k|         else {
   92|  55.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  55.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  55.7k|         }
   94|  55.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  88.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|  88.0k|         else {
   92|  88.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  88.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  88.0k|         }
   94|  88.0k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.9k|         else {
   92|  27.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.9k|         }
   94|  27.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.9k|         else {
   92|  27.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.9k|         }
   94|  27.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.8k|         else {
   92|  27.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.8k|         }
   94|  27.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.67k|         else {
   92|  1.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.67k|         }
   94|  1.67k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.99M|      {
   88|       |         if constexpr( internal::has_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.99M|         else {
   92|  8.99M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.99M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.99M|         }
   94|  8.99M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.94k|      {
   65|  5.94k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.94k|         return Action< Rule >::apply( action_input, st... );
   67|  5.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.65k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.30k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.65k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.30k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  28.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.30k|      {}
_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|  25.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|  25.6k|         else {
   92|  25.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.6k|         }
   94|  25.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|  28.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|  28.7k|         else {
   92|  28.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.7k|         }
   94|  28.7k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  25.3k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  6.03k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  33.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  33.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|  33.4k|         else {
   92|  33.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.4k|         }
   94|  33.4k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  33.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  33.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  33.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    103|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  33.4k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    103|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  33.5k|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  33.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.5k|         else {
   92|  33.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.5k|         }
   94|  33.5k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  33.5k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  33.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.5k|         else {
   92|  33.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.5k|         }
   94|  33.5k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|  4.53k|      {
   49|  4.53k|#if defined( __cpp_exceptions )
   50|  4.53k|         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.53k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  29.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  29.0k|      {}

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

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

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

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