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

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

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

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

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

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

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

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

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

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

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

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

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

_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|  10.2k|  {
  303|  10.2k|    return std::unique_lock<std::mutex>(_mutex);
  304|  10.2k|  }
_ZNK8usbguard6Logger9isEnabledENS_9LogStream5LevelE:
  314|  10.2k|  {
  315|  10.2k|    auto L = lock();
  316|  10.2k|    return (_enabled && _level >= level);
  ------------------
  |  Branch (316:13): [True: 10.2k, False: 0]
  |  Branch (316:25): [True: 0, False: 10.2k]
  ------------------
  317|  10.2k|  }
_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|   125k|    : d_pointer(usbguard::make_unique<RulePrivate>())
   43|   125k|  {
   44|   125k|  }
_ZN8usbguard4RuleD2Ev:
   46|   125k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   54|  80.9k|  {
   55|  80.9k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   56|  80.9k|    return *this;
   57|  80.9k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   70|  43.5k|  {
   71|  43.5k|    d_pointer->setTarget(target);
   72|  43.5k|  }
_ZNK8usbguard4Rule9getTargetEv:
   75|  13.7k|  {
   76|  13.7k|    return d_pointer->getTarget();
   77|  13.7k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   80|  2.77k|  {
   81|  2.77k|    d_pointer->setDeviceID(value);
   82|  2.77k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   95|   810k|  {
   96|   810k|    return d_pointer->attributeDeviceID();
   97|   810k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  115|  10.5k|  {
  116|  10.5k|    return d_pointer->attributeSerial();
  117|  10.5k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  135|  7.08k|  {
  136|  7.08k|    return d_pointer->attributeLabel();
  137|  7.08k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  155|  9.37k|  {
  156|  9.37k|    return d_pointer->attributeWithConnectType();
  157|  9.37k|  }
_ZN8usbguard4Rule13attributeNameEv:
  175|   464k|  {
  176|   464k|    return d_pointer->attributeName();
  177|   464k|  }
_ZN8usbguard4Rule13attributeHashEv:
  195|  14.1k|  {
  196|  14.1k|    return d_pointer->attributeHash();
  197|  14.1k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  215|  9.93k|  {
  216|  9.93k|    return d_pointer->attributeParentHash();
  217|  9.93k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  235|  12.0k|  {
  236|  12.0k|    return d_pointer->attributeViaPort();
  237|  12.0k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  245|   167k|  {
  246|   167k|    return d_pointer->attributeWithInterface();
  247|   167k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  255|   655k|  {
  256|   655k|    return d_pointer->attributeConditions();
  257|   655k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  333|  43.5k|  {
  334|  49.2k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (334:28): [True: 49.2k, False: 0]
  ------------------
  335|  49.2k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (335:11): [True: 43.5k, False: 5.66k]
  ------------------
  336|  43.5k|        return ttable_entry.second;
  337|  43.5k|      }
  338|  49.2k|    }
  339|       |
  340|      0|    throw std::runtime_error("Invalid rule target string");
  341|  43.5k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  387|  17.7k|  {
  388|  65.0k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (388:28): [True: 65.0k, False: 0]
  ------------------
  389|  65.0k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (389:11): [True: 17.7k, False: 47.3k]
  ------------------
  390|  17.7k|        return ttable_entry.second;
  391|  17.7k|      }
  392|  65.0k|    }
  393|       |
  394|      0|    throw std::runtime_error("Invalid set operator string");
  395|  17.7k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  300|  3.83k|      {
  301|  3.83k|        return count() == 0;
  302|  3.83k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  289|  9.38k|      {
  290|  9.38k|        return _values.size();
  291|  9.38k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.73k|      {
  250|  1.73k|        _set_operator = op;
  251|  1.73k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  279|   807k|      {
  280|   807k|        _values.push_back(value);
  281|   807k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  300|  22.7k|      {
  301|  22.7k|        return count() == 0;
  302|  22.7k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  289|  22.7k|      {
  290|  22.7k|        return _values.size();
  291|  22.7k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  249|  11.2k|      {
  250|  11.2k|        _set_operator = op;
  251|  11.2k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  279|   493k|      {
  280|   493k|        _values.push_back(value);
  281|   493k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  300|  4.84k|      {
  301|  4.84k|        return count() == 0;
  302|  4.84k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  289|  4.84k|      {
  290|  4.84k|        return _values.size();
  291|  4.84k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  249|  3.42k|      {
  250|  3.42k|        _set_operator = op;
  251|  3.42k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  279|   159k|      {
  280|   159k|        _values.push_back(value);
  281|   159k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  300|  6.25k|      {
  301|  6.25k|        return count() == 0;
  302|  6.25k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  289|  6.25k|      {
  290|  6.25k|        return _values.size();
  291|  6.25k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.34k|      {
  250|  1.34k|        _set_operator = op;
  251|  1.34k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  269|   645k|      {
  270|   645k|        _values.emplace_back(std::move(value));
  271|   645k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  241|  80.9k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  241|   566k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  241|  80.9k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  241|  80.9k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  224|   206k|      {
  225|   206k|        _name = name;
  226|   206k|        _set_operator = SetOperator::Equals;
  227|   206k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  224|  1.44M|      {
  225|  1.44M|        _name = name;
  226|  1.44M|        _set_operator = SetOperator::Equals;
  227|  1.44M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  224|   206k|      {
  225|   206k|        _name = name;
  226|   206k|        _set_operator = SetOperator::Equals;
  227|   206k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  224|   206k|      {
  225|   206k|        _name = name;
  226|   206k|        _set_operator = SetOperator::Equals;
  227|   206k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  384|  2.77k|      {
  385|  2.77k|        if (count() > 1) {
  ------------------
  |  Branch (385:13): [True: 0, False: 2.77k]
  ------------------
  386|      0|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  387|      0|        }
  388|       |
  389|  2.77k|        if (count() == 0) {
  ------------------
  |  Branch (389:13): [True: 2.77k, False: 0]
  ------------------
  390|  2.77k|          append(value);
  391|  2.77k|        }
  392|      0|        else {
  393|      0|          _values[0] = value;
  394|      0|        }
  395|  2.77k|      }

_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
   34|  47.5k|    : _identifier(identifier),
   35|  47.5k|      _parameter(parameter),
   36|  47.5k|      _negated(negated)
   37|  47.5k|  {
   38|  47.5k|  }
_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   41|   599k|    : _identifier(identifier),
   42|   599k|      _negated(negated)
   43|   599k|  {
   44|   599k|  }
_ZN8usbguard17RuleConditionBaseC2ERKS0_:
   47|  1.52M|    : _identifier(rhs._identifier),
   48|  1.52M|      _parameter(rhs._parameter),
   49|  1.52M|      _negated(rhs._negated)
   50|  1.52M|  {
   51|  1.52M|  }
_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|   647k|  {
  131|   647k|    if (condition_string.empty()) {
  ------------------
  |  Branch (131:9): [True: 0, False: 647k]
  ------------------
  132|      0|      throw std::runtime_error("Empty condition");
  133|      0|    }
  134|       |
  135|   647k|    const bool negated = condition_string[0] == '!';
  136|   647k|    const size_t identifier_start = negated ? 1 : 0;
  ------------------
  |  Branch (136:37): [True: 305, False: 647k]
  ------------------
  137|   647k|    const size_t p_pos = condition_string.find_first_of('(');
  138|   647k|    std::string identifier;
  139|   647k|    std::string parameter;
  140|       |
  141|   647k|    if (p_pos == std::string::npos) {
  ------------------
  |  Branch (141:9): [True: 603k, False: 44.3k]
  ------------------
  142|       |      /*
  143|       |       * The rest of the condition_string should be
  144|       |       * a condition identifier -- without a parameter.
  145|       |       */
  146|   603k|      identifier = condition_string.substr(identifier_start);
  147|       |
  148|   603k|      if (identifier.size() < 1) {
  ------------------
  |  Branch (148:11): [True: 0, False: 603k]
  ------------------
  149|      0|        throw std::runtime_error("Invalid condition string. Missing identifier.");
  150|      0|      }
  151|   603k|    }
  152|  44.3k|    else {
  153|  44.3k|      const size_t parameter_size = condition_string.size() - p_pos;
  154|       |
  155|  44.3k|      if (parameter_size < 3 /* two parentheses + at least one character */) {
  ------------------
  |  Branch (155:11): [True: 9, False: 44.2k]
  ------------------
  156|      9|        throw std::runtime_error("Invalid condition string. Invalid parameter.");
  157|      9|      }
  158|       |
  159|  44.2k|      const size_t identifier_size = p_pos - identifier_start;
  160|  44.2k|      identifier = condition_string.substr(identifier_start, identifier_size);
  161|       |
  162|  44.2k|      if (condition_string[condition_string.size() - 1] != ')') {
  ------------------
  |  Branch (162:11): [True: 0, False: 44.2k]
  ------------------
  163|      0|        throw std::runtime_error("Invalid condition string. Malformed parameter.");
  164|      0|      }
  165|       |
  166|  44.2k|      parameter = condition_string.substr(p_pos + 1, parameter_size - 2);
  167|  44.2k|    }
  168|       |
  169|   647k|    return getImplementation(identifier, parameter, negated);
  170|   647k|  }
_ZN8usbguard17RuleConditionBase17getImplementationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
  174|   647k|  {
  175|   647k|    if (identifier == "allowed-matches") {
  ------------------
  |  Branch (175:9): [True: 34.8k, False: 612k]
  ------------------
  176|  34.8k|      return new AllowedMatchesCondition(parameter, negated);
  177|  34.8k|    }
  178|       |
  179|   612k|    if (identifier == "localtime") {
  ------------------
  |  Branch (179:9): [True: 3.87k, False: 608k]
  ------------------
  180|  3.87k|      return new LocaltimeCondition(parameter, negated);
  181|  3.87k|    }
  182|       |
  183|   608k|    if (identifier == "true") {
  ------------------
  |  Branch (183:9): [True: 598k, False: 9.79k]
  ------------------
  184|   598k|      return new FixedStateCondition(true, negated);
  185|   598k|    }
  186|       |
  187|  9.79k|    if (identifier == "false") {
  ------------------
  |  Branch (187:9): [True: 233, False: 9.56k]
  ------------------
  188|    233|      return new FixedStateCondition(false, negated);
  189|    233|    }
  190|       |
  191|  9.56k|    if (identifier == "random") {
  ------------------
  |  Branch (191:9): [True: 2.97k, False: 6.59k]
  ------------------
  192|  2.97k|      return new RandomStateCondition(parameter, negated);
  193|  2.97k|    }
  194|       |
  195|  6.59k|    if (identifier == "rule-applied") {
  ------------------
  |  Branch (195:9): [True: 2.18k, False: 4.40k]
  ------------------
  196|  2.18k|      return new RuleAppliedCondition(parameter, negated);
  197|  2.18k|    }
  198|       |
  199|  4.40k|    if (identifier == "rule-evaluated") {
  ------------------
  |  Branch (199:9): [True: 3.65k, False: 749]
  ------------------
  200|  3.65k|      return new RuleEvaluatedCondition(parameter, negated);
  201|  3.65k|    }
  202|       |
  203|    749|    throw std::runtime_error("Unknown rule condition");
  204|  4.40k|  }
_ZN8usbguard13RuleConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  211|   647k|    : _condition(RuleConditionBase::getImplementation(condition_string))
  212|   647k|  {
  213|   647k|  }
_ZN8usbguard13RuleConditionC2ERKS0_:
  216|  1.52M|    : _condition(rhs._condition->clone())
  217|  1.52M|  {
  218|  1.52M|  }
_ZN8usbguard13RuleConditionC2EOS0_:
  221|   645k|    : _condition(std::move(rhs._condition))
  222|   645k|  {
  223|   645k|  }

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

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

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

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

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

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    265|{
   36|    265|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    265|   constexpr auto begin = sv.find( '=' );
   38|    265|   static_assert( begin != std::string_view::npos );
   39|    265|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    265|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    352|{
   36|    352|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    352|   constexpr auto begin = sv.find( '=' );
   38|    352|   static_assert( begin != std::string_view::npos );
   39|    352|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    352|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.36k|{
   36|  1.36k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.36k|   constexpr auto begin = sv.find( '=' );
   38|  1.36k|   static_assert( begin != std::string_view::npos );
   39|  1.36k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.36k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     68|{
   36|     68|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     68|   constexpr auto begin = sv.find( '=' );
   38|     68|   static_assert( begin != std::string_view::npos );
   39|     68|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     68|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    278|{
   36|    278|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    278|   constexpr auto begin = sv.find( '=' );
   38|    278|   static_assert( begin != std::string_view::npos );
   39|    278|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    278|}
_ZN3tao5pegtl8demangleINS0_3eofEEENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEv:
   35|  4.57k|{
   36|  4.57k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.57k|   constexpr auto begin = sv.find( '=' );
   38|  4.57k|   static_assert( begin != std::string_view::npos );
   39|  4.57k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.57k|}

_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|  48.0k|      {
   45|  48.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  48.0k|      }
_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|  44.6k|      {
   45|  44.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  44.6k|      }
_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|  40.7k|      {
   45|  40.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  40.7k|      }
_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|  36.6k|      {
   45|  36.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  36.6k|      }
_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|  33.8k|      {
   45|  33.8k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  33.8k|      }
_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|  30.4k|      {
   45|  30.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  30.4k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser22with_interface_actionsEJNS4_14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  26.7k|      {
   45|  26.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  26.7k|      }
_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|  22.3k|      {
   45|  22.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  22.3k|      }
_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|  19.5k|      {
   45|  19.5k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  19.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|  14.0k|      {
   45|  14.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  14.0k|      }

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

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

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

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.71M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.71M|      else {
   20|  3.71M|         in.bump_in_this_line( count );
   21|  3.71M|      }
   22|  3.71M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  13.7k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  13.7k|      else {
   20|  13.7k|         in.bump_in_this_line( count );
   21|  13.7k|      }
   22|  13.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  39.7k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  39.7k|      else {
   20|  39.7k|         in.bump_in_this_line( count );
   21|  39.7k|      }
   22|  39.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.84k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.84k|      else {
   20|  2.84k|         in.bump_in_this_line( count );
   21|  2.84k|      }
   22|  2.84k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_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|    881|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    881|      else {
   20|    881|         in.bump_in_this_line( count );
   21|    881|      }
   22|    881|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     38|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     38|      else {
   20|     38|         in.bump_in_this_line( count );
   21|     38|      }
   22|     38|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.31M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.31M|      else {
   20|  1.31M|         in.bump_in_this_line( count );
   21|  1.31M|      }
   22|  1.31M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.76M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.76M|      else {
   20|  1.76M|         in.bump_in_this_line( count );
   21|  1.76M|      }
   22|  1.76M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.12M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.12M|      else {
   20|  1.12M|         in.bump_in_this_line( count );
   21|  1.12M|      }
   22|  1.12M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.83k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.83k|      else {
   20|  3.83k|         in.bump_in_this_line( count );
   21|  3.83k|      }
   22|  3.83k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.15k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.15k|      else {
   20|  3.15k|         in.bump_in_this_line( count );
   21|  3.15k|      }
   22|  3.15k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.74k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.74k|      else {
   20|  2.74k|         in.bump_in_this_line( count );
   21|  2.74k|      }
   22|  2.74k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.68k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.68k|      else {
   20|  2.68k|         in.bump_in_this_line( count );
   21|  2.68k|      }
   22|  2.68k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.82k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.82k|      else {
   20|  2.82k|         in.bump_in_this_line( count );
   21|  2.82k|      }
   22|  2.82k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.28k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.28k|      else {
   20|  3.28k|         in.bump_in_this_line( count );
   21|  3.28k|      }
   22|  3.28k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_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_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  28.2k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  28.2k|      else {
   20|  28.2k|         in.bump_in_this_line( count );
   21|  28.2k|      }
   22|  28.2k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  24.5k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  24.5k|      else {
   20|  24.5k|         in.bump_in_this_line( count );
   21|  24.5k|      }
   22|  24.5k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.26k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.26k|      else {
   20|  4.26k|         in.bump_in_this_line( count );
   21|  4.26k|      }
   22|  4.26k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   997k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   997k|      else {
   20|   997k|         in.bump_in_this_line( count );
   21|   997k|      }
   22|   997k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   948k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   948k|      else {
   20|   948k|         in.bump_in_this_line( count );
   21|   948k|      }
   22|   948k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   321k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   321k|      else {
   20|   321k|         in.bump_in_this_line( count );
   21|   321k|      }
   22|   321k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   339k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   339k|      else {
   20|   339k|         in.bump_in_this_line( count );
   21|   339k|      }
   22|   339k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   349k|   {
   16|   349k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|   349k|         in.bump( count );
   18|       |      }
   19|       |      else {
   20|       |         in.bump_in_this_line( count );
   21|       |      }
   22|   349k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   105M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   105M|      else {
   20|   105M|         in.bump_in_this_line( count );
   21|   105M|      }
   22|   105M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.49k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.49k|      else {
   20|  4.49k|         in.bump_in_this_line( count );
   21|  4.49k|      }
   22|  4.49k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.17k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.17k|      else {
   20|  3.17k|         in.bump_in_this_line( count );
   21|  3.17k|      }
   22|  3.17k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.57k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.57k|      else {
   20|  3.57k|         in.bump_in_this_line( count );
   21|  3.57k|      }
   22|  3.57k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.12k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.12k|      else {
   20|  4.12k|         in.bump_in_this_line( count );
   21|  4.12k|      }
   22|  4.12k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.84k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.84k|      else {
   20|  4.84k|         in.bump_in_this_line( count );
   21|  4.84k|      }
   22|  4.84k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.08k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.08k|      else {
   20|  3.08k|         in.bump_in_this_line( count );
   21|  3.08k|      }
   22|  3.08k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  6.25k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  6.25k|      else {
   20|  6.25k|         in.bump_in_this_line( count );
   21|  6.25k|      }
   22|  6.25k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|    310|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    310|      else {
   20|    310|         in.bump_in_this_line( count );
   21|    310|      }
   22|    310|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   647k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   647k|      else {
   20|   647k|         in.bump_in_this_line( count );
   21|   647k|      }
   22|   647k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  26.3M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  26.3M|      else {
   20|  26.3M|         in.bump_in_this_line( count );
   21|  26.3M|      }
   22|  26.3M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  44.7k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  44.7k|      else {
   20|  44.7k|         in.bump_in_this_line( count );
   21|  44.7k|      }
   22|  44.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  44.5k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  44.5k|      else {
   20|  44.5k|         in.bump_in_this_line( count );
   21|  44.5k|      }
   22|  44.5k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc108ELc97ELc98ELc101ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.05k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.05k|      else {
   20|  4.05k|         in.bump_in_this_line( count );
   21|  4.05k|      }
   22|  4.05k|   }

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

_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|  82.5k|      {
   38|  82.5k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 13.7k, False: 68.8k]
  ------------------
   39|  13.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  13.7k|            return true;
   41|  13.7k|         }
   42|  68.8k|         return Default;
   43|  82.5k|      }
_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|   459k|      {
   38|   459k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 458k, False: 1.05k]
  ------------------
   39|   458k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   458k|            return true;
   41|   458k|         }
   42|  1.05k|         return Default;
   43|   459k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  16.3M|      {
   38|  16.3M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 244k, False: 16.0M]
  ------------------
   39|   244k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   244k|            return true;
   41|   244k|         }
   42|  16.0M|         return Default;
   43|  16.3M|      }
_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|   244k|      {
   38|   244k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 100k, False: 143k]
  ------------------
   39|   100k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   100k|            return true;
   41|   100k|         }
   42|   143k|         return Default;
   43|   244k|      }
_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|   143k|      {
   38|   143k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 44.9k, False: 98.4k]
  ------------------
   39|  44.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  44.9k|            return true;
   41|  44.9k|         }
   42|  98.4k|         return Default;
   43|   143k|      }
_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.92k|      {
   38|  8.92k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 7.69k, False: 1.23k]
  ------------------
   39|  7.69k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  7.69k|            return true;
   41|  7.69k|         }
   42|  1.23k|         return Default;
   43|  8.92k|      }
_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|  6.90M|      {
   38|  6.90M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 76.3k, False: 6.83M]
  ------------------
   39|  76.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  76.3k|            return true;
   41|  76.3k|         }
   42|  6.83M|         return Default;
   43|  6.90M|      }
_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|  76.3k|      {
   38|  76.3k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 20.4k, False: 55.9k]
  ------------------
   39|  20.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  20.4k|            return true;
   41|  20.4k|         }
   42|  55.9k|         return Default;
   43|  76.3k|      }
_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|  55.9k|      {
   38|  55.9k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 32.4k, False: 23.4k]
  ------------------
   39|  32.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  32.4k|            return true;
   41|  32.4k|         }
   42|  23.4k|         return Default;
   43|  55.9k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.70k|      {
   38|  6.70k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.86k, False: 843]
  ------------------
   39|  5.86k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.86k|            return true;
   41|  5.86k|         }
   42|    843|         return Default;
   43|  6.70k|      }
_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|  6.02M|      {
   38|  6.02M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 85.9k, False: 5.93M]
  ------------------
   39|  85.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  85.9k|            return true;
   41|  85.9k|         }
   42|  5.93M|         return Default;
   43|  6.02M|      }
_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|  85.9k|      {
   38|  85.9k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 37.8k, False: 48.1k]
  ------------------
   39|  37.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  37.8k|            return true;
   41|  37.8k|         }
   42|  48.1k|         return Default;
   43|  85.9k|      }
_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|  48.1k|      {
   38|  48.1k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 14.7k, False: 33.3k]
  ------------------
   39|  14.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  14.7k|            return true;
   41|  14.7k|         }
   42|  33.3k|         return Default;
   43|  48.1k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.16k|      {
   38|  6.16k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.58k, False: 580]
  ------------------
   39|  5.58k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.58k|            return true;
   41|  5.58k|         }
   42|    580|         return Default;
   43|  6.16k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  2.38M|      {
   38|  2.38M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.35k, False: 2.37M]
  ------------------
   39|  5.35k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.35k|            return true;
   41|  5.35k|         }
   42|  2.37M|         return Default;
   43|  2.38M|      }
_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.35k|      {
   38|  5.35k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 1.46k, False: 3.89k]
  ------------------
   39|  1.46k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  1.46k|            return true;
   41|  1.46k|         }
   42|  3.89k|         return Default;
   43|  5.35k|      }
_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.89k|      {
   38|  3.89k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 1.00k, False: 2.88k]
  ------------------
   39|  1.00k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  1.00k|            return true;
   41|  1.00k|         }
   42|  2.88k|         return Default;
   43|  3.89k|      }
_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|  8.03k|      {
   38|  8.03k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.61k, False: 1.42k]
  ------------------
   39|  6.61k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.61k|            return true;
   41|  6.61k|         }
   42|  1.42k|         return Default;
   43|  8.03k|      }
_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|  8.10M|      {
   38|  8.10M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 106k, False: 8.00M]
  ------------------
   39|   106k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   106k|            return true;
   41|   106k|         }
   42|  8.00M|         return Default;
   43|  8.10M|      }
_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|   106k|      {
   38|   106k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 44.0k, False: 62.6k]
  ------------------
   39|  44.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  44.0k|            return true;
   41|  44.0k|         }
   42|  62.6k|         return Default;
   43|   106k|      }
_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|  62.6k|      {
   38|  62.6k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.8k, False: 31.7k]
  ------------------
   39|  30.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.8k|            return true;
   41|  30.8k|         }
   42|  31.7k|         return Default;
   43|  62.6k|      }
_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|  6.12k|      {
   38|  6.12k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.22k, False: 893]
  ------------------
   39|  5.22k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.22k|            return true;
   41|  5.22k|         }
   42|    893|         return Default;
   43|  6.12k|      }
_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|  8.25M|      {
   38|  8.25M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 101k, False: 8.14M]
  ------------------
   39|   101k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   101k|            return true;
   41|   101k|         }
   42|  8.14M|         return Default;
   43|  8.25M|      }
_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|   101k|      {
   38|   101k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 24.5k, False: 77.2k]
  ------------------
   39|  24.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  24.5k|            return true;
   41|  24.5k|         }
   42|  77.2k|         return Default;
   43|   101k|      }
_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|  77.2k|      {
   38|  77.2k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 34.1k, False: 43.0k]
  ------------------
   39|  34.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  34.1k|            return true;
   41|  34.1k|         }
   42|  43.0k|         return Default;
   43|  77.2k|      }
_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|   647k|      {
   38|   647k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 44.7k, False: 603k]
  ------------------
   39|  44.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  44.7k|            return true;
   41|  44.7k|         }
   42|   603k|         return Default;
   43|   647k|      }
_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|  48.2M|      {
   38|  48.2M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 148k, False: 48.1M]
  ------------------
   39|   148k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   148k|            return true;
   41|   148k|         }
   42|  48.1M|         return Default;
   43|  48.2M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   148k|      {
   38|   148k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 38.3k, False: 110k]
  ------------------
   39|  38.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  38.3k|            return true;
   41|  38.3k|         }
   42|   110k|         return Default;
   43|   148k|      }
_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|   110k|      {
   38|   110k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 29.1k, False: 81.2k]
  ------------------
   39|  29.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  29.1k|            return true;
   41|  29.1k|         }
   42|  81.2k|         return Default;
   43|   110k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.87k|      {
   38|  6.87k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.00k, False: 866]
  ------------------
   39|  6.00k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.00k|            return true;
   41|  6.00k|         }
   42|    866|         return Default;
   43|  6.87k|      }
_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.90M|      {
   38|  9.90M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 179k, False: 9.72M]
  ------------------
   39|   179k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   179k|            return true;
   41|   179k|         }
   42|  9.72M|         return Default;
   43|  9.90M|      }
_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|   179k|      {
   38|   179k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 54.0k, False: 125k]
  ------------------
   39|  54.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  54.0k|            return true;
   41|  54.0k|         }
   42|   125k|         return Default;
   43|   179k|      }
_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|   125k|      {
   38|   125k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 81.1k, False: 44.6k]
  ------------------
   39|  81.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  81.1k|            return true;
   41|  81.1k|         }
   42|  44.6k|         return Default;
   43|   125k|      }

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

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

_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEC2ERKS3_:
   19|   594M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEC2ERS3_:
   42|  9.02M|         : m_saved( i ),
   43|  9.02M|           m_input( &i )
   44|  9.02M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEclEb:
   60|  6.33M|      {
   61|  6.33M|         if( result ) {
  ------------------
  |  Branch (61:14): [True: 5.49M, False: 839k]
  ------------------
   62|  5.49M|            m_input = nullptr;
   63|  5.49M|            return true;
   64|  5.49M|         }
   65|   839k|         return false;
   66|  6.33M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EE8iteratorEv:
   69|  2.20M|      {
   70|  2.20M|         return m_saved;
   71|  2.20M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEC2ERKS3_:
   19|  2.55M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEclEb:
   30|  2.54M|      {
   31|  2.54M|         return result;
   32|  2.54M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EED2Ev:
   50|  9.02M|      {
   51|  9.02M|         if( m_input != nullptr ) {
  ------------------
  |  Branch (51:14): [True: 3.53M, False: 5.49M]
  ------------------
   52|  3.53M|            ( *m_input ) = m_saved;
   53|  3.53M|         }
   54|  9.02M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEclEb:
   30|   594M|      {
   31|   594M|         return result;
   32|   594M|      }

_ZN3tao5pegtl8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEbRT3_DpOT4_:
   55|  13.7k|      {
   56|  13.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 13.7k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  13.7k|         return true;
   60|  13.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   458k|      {
   56|   458k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 217, False: 458k]
  ------------------
   57|    217|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    217|         }
   59|   458k|         return true;
   60|   458k|      }
_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|   244k|      {
   56|   244k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 57, False: 244k]
  ------------------
   57|     57|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     57|         }
   59|   244k|         return true;
   60|   244k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|   100k|      {
   56|   100k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 23, False: 100k]
  ------------------
   57|     23|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     23|         }
   59|   100k|         return true;
   60|   100k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  44.9k|      {
   56|  44.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 44.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  44.9k|         return true;
   60|  44.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.69k|      {
   56|  7.69k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 208, False: 7.48k]
  ------------------
   57|    208|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    208|         }
   59|  7.69k|         return true;
   60|  7.69k|      }
_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|  76.3k|      {
   56|  76.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 58, False: 76.3k]
  ------------------
   57|     58|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     58|         }
   59|  76.3k|         return true;
   60|  76.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  20.4k|      {
   56|  20.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 47, False: 20.3k]
  ------------------
   57|     47|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     47|         }
   59|  20.4k|         return true;
   60|  20.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  32.4k|      {
   56|  32.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 32.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  32.4k|         return true;
   60|  32.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.86k|      {
   56|  5.86k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 183, False: 5.67k]
  ------------------
   57|    183|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    183|         }
   59|  5.86k|         return true;
   60|  5.86k|      }
_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|  85.9k|      {
   56|  85.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 51, False: 85.9k]
  ------------------
   57|     51|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     51|         }
   59|  85.9k|         return true;
   60|  85.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  37.8k|      {
   56|  37.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 26, False: 37.8k]
  ------------------
   57|     26|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     26|         }
   59|  37.8k|         return true;
   60|  37.8k|      }
_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|  14.7k|      {
   56|  14.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 14.7k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  14.7k|         return true;
   60|  14.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.58k|      {
   56|  5.58k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 162, False: 5.42k]
  ------------------
   57|    162|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    162|         }
   59|  5.58k|         return true;
   60|  5.58k|      }
_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.35k|      {
   56|  5.35k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 24, False: 5.33k]
  ------------------
   57|     24|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     24|         }
   59|  5.35k|         return true;
   60|  5.35k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  1.46k|      {
   56|  1.46k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 1.44k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|  1.46k|         return true;
   60|  1.46k|      }
_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.00k|      {
   56|  1.00k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 1.00k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  1.00k|         return true;
   60|  1.00k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.61k|      {
   56|  6.61k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 200, False: 6.41k]
  ------------------
   57|    200|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    200|         }
   59|  6.61k|         return true;
   60|  6.61k|      }
_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|   106k|      {
   56|   106k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 64, False: 106k]
  ------------------
   57|     64|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     64|         }
   59|   106k|         return true;
   60|   106k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  44.0k|      {
   56|  44.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 44.0k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|  44.0k|         return true;
   60|  44.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  30.8k|      {
   56|  30.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 30.8k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  30.8k|         return true;
   60|  30.8k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.22k|      {
   56|  5.22k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 188, False: 5.04k]
  ------------------
   57|    188|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    188|         }
   59|  5.22k|         return true;
   60|  5.22k|      }
_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|   101k|      {
   56|   101k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 28, False: 101k]
  ------------------
   57|     28|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     28|         }
   59|   101k|         return true;
   60|   101k|      }
_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|  24.5k|      {
   56|  24.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 37, False: 24.5k]
  ------------------
   57|     37|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     37|         }
   59|  24.5k|         return true;
   60|  24.5k|      }
_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|  34.1k|      {
   56|  34.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 34.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  34.1k|         return true;
   60|  34.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  44.7k|      {
   56|  44.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 278, False: 44.4k]
  ------------------
   57|    278|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    278|         }
   59|  44.7k|         return true;
   60|  44.7k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   148k|      {
   56|   148k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 68, False: 148k]
  ------------------
   57|     68|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     68|         }
   59|   148k|         return true;
   60|   148k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  38.3k|      {
   56|  38.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 51, False: 38.3k]
  ------------------
   57|     51|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     51|         }
   59|  38.3k|         return true;
   60|  38.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  29.1k|      {
   56|  29.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 29.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  29.1k|         return true;
   60|  29.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.00k|      {
   56|  6.00k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 202, False: 5.80k]
  ------------------
   57|    202|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    202|         }
   59|  6.00k|         return true;
   60|  6.00k|      }
_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|   179k|      {
   56|   179k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 70, False: 179k]
  ------------------
   57|     70|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     70|         }
   59|   179k|         return true;
   60|   179k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  54.0k|      {
   56|  54.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 39, False: 54.0k]
  ------------------
   57|     39|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     39|         }
   59|  54.0k|         return true;
   60|  54.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  81.1k|      {
   56|  81.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 81.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  81.1k|         return true;
   60|  81.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   55|  39.0k|      {
   56|  39.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.57k, False: 34.4k]
  ------------------
   57|  4.57k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.57k|         }
   59|  39.0k|         return true;
   60|  39.0k|      }

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

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  6.21M|      {
   41|  6.21M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 6.13M, False: 80.2k]
  ------------------
   42|  6.13M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 3.71M, False: 2.41M]
  ------------------
   43|  3.71M|               bump_help< one >( in, t.size );
   44|  3.71M|               return true;
   45|  3.71M|            }
   46|  6.13M|         }
   47|  2.49M|         return false;
   48|  6.21M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  6.13M|      {
   32|  8.62M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 3.63M, False: 2.49M]
  |  Branch (32:19): [True: 78.7k, False: 2.41M]
  ------------------
   33|  6.13M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  82.5k|      {
   41|  82.5k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 61.9k, False: 20.6k]
  ------------------
   42|  61.9k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 13.7k, False: 48.1k]
  ------------------
   43|  13.7k|               bump_help< one >( in, t.size );
   44|  13.7k|               return true;
   45|  13.7k|            }
   46|  61.9k|         }
   47|  68.8k|         return false;
   48|  82.5k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  61.9k|      {
   32|  61.9k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  61.9k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.80M|      {
   41|  1.80M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.80M, False: 1.13k]
  ------------------
   42|  1.80M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.76M, False: 41.2k]
  ------------------
   43|  1.76M|               bump_help< one >( in, t.size );
   44|  1.76M|               return true;
   45|  1.76M|            }
   46|  1.80M|         }
   47|  42.3k|         return false;
   48|  1.80M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  1.80M|      {
   32|  1.80M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.80M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.12M|      {
   41|  1.12M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.12M, False: 44]
  ------------------
   42|  1.12M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.12M, False: 84]
  ------------------
   43|  1.12M|               bump_help< one >( in, t.size );
   44|  1.12M|               return true;
   45|  1.12M|            }
   46|  1.12M|         }
   47|    128|         return false;
   48|  1.12M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|  1.12M|      {
   32|  1.12M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.12M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  41.5k|      {
   41|  41.5k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 41.0k, False: 432]
  ------------------
   42|  41.0k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 28.2k, False: 12.8k]
  ------------------
   43|  28.2k|               bump_help< one >( in, t.size );
   44|  28.2k|               return true;
   45|  28.2k|            }
   46|  41.0k|         }
   47|  13.2k|         return false;
   48|  41.5k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  41.0k|      {
   32|  41.0k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  41.0k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  26.3k|      {
   41|  26.3k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 25.1k, False: 1.25k]
  ------------------
   42|  25.1k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 24.5k, False: 639]
  ------------------
   43|  24.5k|               bump_help< one >( in, t.size );
   44|  24.5k|               return true;
   45|  24.5k|            }
   46|  25.1k|         }
   47|  1.88k|         return false;
   48|  26.3k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  25.1k|      {
   32|  25.1k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  25.1k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  58.8M|      {
   41|  58.8M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 58.8M, False: 1.99k]
  ------------------
   42|  58.8M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 997k, False: 57.8M]
  ------------------
   43|   997k|               bump_help< one >( in, t.size );
   44|   997k|               return true;
   45|   997k|            }
   46|  58.8M|         }
   47|  57.8M|         return false;
   48|  58.8M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  58.8M|      {
   32|  58.8M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  58.8M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   106M|      {
   41|   106M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 106M, False: 1.60k]
  ------------------
   42|   106M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 948k, False: 105M]
  ------------------
   43|   948k|               bump_help< one >( in, t.size );
   44|   948k|               return true;
   45|   948k|            }
   46|   106M|         }
   47|   105M|         return false;
   48|   106M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|   106M|      {
   32|   106M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   106M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   948k|      {
   41|   948k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 948k, False: 96]
  ------------------
   42|   948k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 321k, False: 627k]
  ------------------
   43|   321k|               bump_help< one >( in, t.size );
   44|   321k|               return true;
   45|   321k|            }
   46|   948k|         }
   47|   627k|         return false;
   48|   948k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|   948k|      {
   32|   948k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   948k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   358k|      {
   41|   358k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 358k, False: 96]
  ------------------
   42|   358k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 349k, False: 9.50k]
  ------------------
   43|   349k|               bump_help< one >( in, t.size );
   44|   349k|               return true;
   45|   349k|            }
   46|   358k|         }
   47|  9.60k|         return false;
   48|   358k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   358k|      {
   32|  3.03M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 26.0k]
  |  Branch (32:19): [True: 16.5k, False: 9.50k]
  |  Branch (32:19): [True: 24.3k, False: 26.0k]
  |  Branch (32:19): [True: 47.4k, False: 50.4k]
  |  Branch (32:19): [True: 10.6k, False: 97.8k]
  |  Branch (32:19): [True: 21.5k, False: 108k]
  |  Branch (32:19): [True: 30.4k, False: 130k]
  |  Branch (32:19): [True: 27.6k, False: 160k]
  |  Branch (32:19): [True: 58.6k, False: 188k]
  |  Branch (32:19): [True: 70.8k, False: 246k]
  |  Branch (32:19): [True: 41.1k, False: 317k]
  ------------------
   33|   358k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   105M|      {
   41|   105M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 105M, False: 1.60k]
  ------------------
   42|   105M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 105M, False: 33]
  ------------------
   43|   105M|               bump_help< one >( in, t.size );
   44|   105M|               return true;
   45|   105M|            }
   46|   105M|         }
   47|  1.63k|         return false;
   48|   105M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|   105M|      {
   32|   210M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 15, False: 105M]
  |  Branch (32:19): [True: 18, False: 105M]
  ------------------
   33|   105M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   649k|      {
   41|   649k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 648k, False: 106]
  ------------------
   42|   648k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 310, False: 648k]
  ------------------
   43|    310|               bump_help< one >( in, t.size );
   44|    310|               return true;
   45|    310|            }
   46|   648k|         }
   47|   648k|         return false;
   48|   649k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   648k|      {
   32|   648k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   648k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   647k|      {
   41|   647k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 646k, False: 1.31k]
  ------------------
   42|   646k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 44.7k, False: 601k]
  ------------------
   43|  44.7k|               bump_help< one >( in, t.size );
   44|  44.7k|               return true;
   45|  44.7k|            }
   46|   646k|         }
   47|   603k|         return false;
   48|   647k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   646k|      {
   32|   646k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   646k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  48.3M|      {
   41|  48.3M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 48.3M, False: 286]
  ------------------
   42|  48.3M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 44.5k, False: 48.2M]
  ------------------
   43|  44.5k|               bump_help< one >( in, t.size );
   44|  44.5k|               return true;
   45|  44.5k|            }
   46|  48.3M|         }
   47|  48.2M|         return false;
   48|  48.3M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  48.3M|      {
   32|  48.3M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  48.3M|      }

_ZN3tao5pegtl8internal3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  43.6k|      {
   47|  43.6k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  43.6k|         return true;
   49|  43.6k|      }
_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|  43.5k|      {
   47|  43.5k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  43.5k|         return true;
   49|  43.5k|      }
_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|  43.5k|      {
   47|  43.5k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  43.5k|         return true;
   49|  43.5k|      }
_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.81k|      {
   47|  3.81k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.81k|         return true;
   49|  3.81k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.24k|      {
   47|  4.24k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.24k|         return true;
   49|  4.24k|      }
_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.47k|      {
   47|  4.47k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.47k|         return true;
   49|  4.47k|      }
_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.15k|      {
   47|  3.15k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.15k|         return true;
   49|  3.15k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.55k|      {
   47|  3.55k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.55k|         return true;
   49|  3.55k|      }
_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|  4.10k|      {
   47|  4.10k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.10k|         return true;
   49|  4.10k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.83k|      {
   47|  4.83k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.83k|         return true;
   49|  4.83k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.07k|      {
   47|  3.07k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.07k|         return true;
   49|  3.07k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  6.21k|      {
   47|  6.21k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  6.21k|         return true;
   49|  6.21k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   649k|      {
   47|   649k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   649k|         return true;
   49|   649k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   647k|      {
   47|   647k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   647k|         return true;
   49|   647k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.03k|      {
   47|  4.03k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.03k|         return true;
   49|  4.03k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  38.8k|      {
   47|  38.8k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.8k|         return true;
   49|  38.8k|      }

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

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   120k|      {
   46|   120k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 91.5k, False: 28.5k]
  ------------------
   47|   102k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 10.5k, False: 91.5k]
  ------------------
   48|  10.5k|            }
   49|  91.5k|            return true;
   50|  91.5k|         }
   51|  28.5k|         return false;
   52|   120k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   809k|      {
   46|   809k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 807k, False: 1.24k]
  ------------------
   47|   814k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 6.63k, False: 807k]
  ------------------
   48|  6.63k|            }
   49|   807k|            return true;
   50|   807k|         }
   51|  1.24k|         return false;
   52|   809k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   463k|      {
   46|   463k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 461k, False: 2.41k]
  ------------------
   47|   464k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.59k, False: 461k]
  ------------------
   48|  3.59k|            }
   49|   461k|            return true;
   50|   461k|         }
   51|  2.41k|         return false;
   52|   463k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  13.2k|      {
   46|  13.2k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 10.9k, False: 2.36k]
  ------------------
   47|  13.7k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.88k, False: 10.9k]
  ------------------
   48|  2.88k|            }
   49|  10.9k|            return true;
   50|  10.9k|         }
   51|  2.36k|         return false;
   52|  13.2k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.26k|      {
   46|  9.26k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.65k, False: 1.61k]
  ------------------
   47|  9.49k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.83k, False: 7.65k]
  ------------------
   48|  1.83k|            }
   49|  7.65k|            return true;
   50|  7.65k|         }
   51|  1.61k|         return false;
   52|  9.26k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.34k|      {
   46|  9.34k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.56k, False: 1.77k]
  ------------------
   47|  10.8k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.23k, False: 7.56k]
  ------------------
   48|  3.23k|            }
   49|  7.56k|            return true;
   50|  7.56k|         }
   51|  1.77k|         return false;
   52|  9.34k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  11.2k|      {
   46|  11.2k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 9.42k, False: 1.81k]
  ------------------
   47|  12.4k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.99k, False: 9.42k]
  ------------------
   48|  2.99k|            }
   49|  9.42k|            return true;
   50|  9.42k|         }
   51|  1.81k|         return false;
   52|  11.2k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   167k|      {
   46|   167k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 164k, False: 2.25k]
  ------------------
   47|  1.52M|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.36M, False: 164k]
  ------------------
   48|  1.36M|            }
   49|   164k|            return true;
   50|   164k|         }
   51|  2.25k|         return false;
   52|   167k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.16k|      {
   46|  9.16k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.23k, False: 1.93k]
  ------------------
   47|  10.7k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.48k, False: 7.23k]
  ------------------
   48|  3.48k|            }
   49|  7.23k|            return true;
   50|  7.23k|         }
   51|  1.93k|         return false;
   52|  9.16k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   652k|      {
   46|   652k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 649k, False: 2.33k]
  ------------------
   47|   686k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 36.8k, False: 649k]
  ------------------
   48|  36.8k|            }
   49|   649k|            return true;
   50|   649k|         }
   51|  2.33k|         return false;
   52|   652k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.83k|      {
   46|  9.83k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.03k, False: 1.80k]
  ------------------
   47|  9.84k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.80k, False: 8.03k]
  ------------------
   48|  1.80k|            }
   49|  8.03k|            return true;
   50|  8.03k|         }
   51|  1.80k|         return false;
   52|  9.83k|      }

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

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  3.12M|      {
   60|  3.12M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 3.12M, False: 1.42k]
  ------------------
   61|  3.12M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 1.31M, False: 1.80M]
  ------------------
   62|  1.31M|               bump_help< ranges >( in, t.size );
   63|  1.31M|               return true;
   64|  1.31M|            }
   65|  3.12M|         }
   66|  1.80M|         return false;
   67|  3.12M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  3.12M|      {
   51|  3.12M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  3.12M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  3.12M|      {
   40|  3.12M|         constexpr const data_t cs[] = { Cs... };
   41|  3.12M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|  11.1M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 376k, False: 2.42M]
  |  Branch (42:22): [True: 625k, False: 1.80M]
  |  Branch (42:22): [True: 316k, False: 2.80M]
  ------------------
   43|       |         }
   44|       |         else {
   45|       |            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
   46|       |         }
   47|  3.12M|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc48ETnS3_Lc57EEEbS3_:
   23|  4.14M|   {
   24|  4.14M|      static_assert( Lo <= Hi, "invalid range" );
   25|  4.14M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 1.37M, False: 2.77M]
  |  Branch (25:29): [True: 330k, False: 1.04M]
  ------------------
   26|  4.14M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc102EEEbS3_:
   23|  2.80M|   {
   24|  2.80M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.80M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 418k, False: 2.38M]
  |  Branch (25:29): [True: 376k, False: 41.2k]
  ------------------
   26|  2.80M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc70EEEbS3_:
   23|  2.42M|   {
   24|  2.42M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.42M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 667k, False: 1.76M]
  |  Branch (25:29): [True: 625k, False: 41.2k]
  ------------------
   26|  2.42M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   649k|      {
   60|   649k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 648k, False: 111]
  ------------------
   61|   648k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 647k, False: 991]
  ------------------
   62|   647k|               bump_help< ranges >( in, t.size );
   63|   647k|               return true;
   64|   647k|            }
   65|   648k|         }
   66|  1.10k|         return false;
   67|   649k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   648k|      {
   51|   648k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   648k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   648k|      {
   40|   648k|         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|   648k|         else {
   45|  1.29M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 647k, False: 1.07k]
  |  Branch (45:22): [True: 49, False: 1.02k]
  |  Branch (45:96): [True: 34, False: 991]
  ------------------
   46|   648k|         }
   47|   648k|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc122EEEbS3_:
   23|  27.6M|   {
   24|  27.6M|      static_assert( Lo <= Hi, "invalid range" );
   25|  27.6M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.24M, False: 22.4M]
  |  Branch (25:29): [True: 5.24M, False: 2.56k]
  ------------------
   26|  27.6M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc90EEEbS3_:
   23|  22.4M|   {
   24|  22.4M|      static_assert( Lo <= Hi, "invalid range" );
   25|  22.4M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 21.4M, False: 1.02M]
  |  Branch (25:29): [True: 21.4M, False: 2.57k]
  ------------------
   26|  22.4M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  27.0M|      {
   60|  27.0M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 27.0M, False: 1.31k]
  ------------------
   61|  27.0M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 26.3M, False: 646k]
  ------------------
   62|  26.3M|               bump_help< ranges >( in, t.size );
   63|  26.3M|               return true;
   64|  26.3M|            }
   65|  27.0M|         }
   66|   647k|         return false;
   67|  27.0M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  27.0M|      {
   51|  27.0M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  27.0M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  27.0M|      {
   40|  27.0M|         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|  27.0M|         else {
   45|  99.9M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 21.4M, False: 1.02M]
  |  Branch (45:22): [True: 13.7k, False: 1.01M]
  |  Branch (45:22): [True: 4.59M, False: 22.4M]
  |  Branch (45:96): [True: 364k, False: 646k]
  ------------------
   46|  27.0M|         }
   47|  27.0M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  46.3k|      {
   50|  46.3k|         auto m = in.template mark< M >();
   51|  46.3k|         using m_t = decltype( m );
   52|       |
   53|  58.9k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 55.8k, False: 3.13k]
  ------------------
   54|  55.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 43.1k, False: 12.6k]
  ------------------
   55|  43.1k|               return false;
   56|  43.1k|            }
   57|  55.8k|         }
   58|  3.13k|         return m( true );
   59|  46.3k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.61M|      {
   50|  1.61M|         auto m = in.template mark< M >();
   51|  1.61M|         using m_t = decltype( m );
   52|       |
   53|  1.61M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.61M, False: 1.59k]
  ------------------
   54|  1.61M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.60M, False: 6.52k]
  ------------------
   55|  1.60M|               return false;
   56|  1.60M|            }
   57|  1.61M|         }
   58|  1.59k|         return m( true );
   59|  1.61M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   100k|      {
   50|   100k|         auto m = in.template mark< M >();
   51|   100k|         using m_t = decltype( m );
   52|       |
   53|   302k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 201k, False: 100k]
  ------------------
   54|   201k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 23, False: 201k]
  ------------------
   55|     23|               return false;
   56|     23|            }
   57|   201k|         }
   58|   100k|         return m( true );
   59|   100k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  20.4k|      {
   50|  20.4k|         auto m = in.template mark< M >();
   51|  20.4k|         using m_t = decltype( m );
   52|       |
   53|  61.1k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 40.8k, False: 20.3k]
  ------------------
   54|  40.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 47, False: 40.7k]
  ------------------
   55|     47|               return false;
   56|     47|            }
   57|  40.8k|         }
   58|  20.3k|         return m( true );
   59|  20.4k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  37.8k|      {
   50|  37.8k|         auto m = in.template mark< M >();
   51|  37.8k|         using m_t = decltype( m );
   52|       |
   53|   113k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 75.6k, False: 37.8k]
  ------------------
   54|  75.6k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 26, False: 75.6k]
  ------------------
   55|     26|               return false;
   56|     26|            }
   57|  75.6k|         }
   58|  37.8k|         return m( true );
   59|  37.8k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.46k|      {
   50|  1.46k|         auto m = in.template mark< M >();
   51|  1.46k|         using m_t = decltype( m );
   52|       |
   53|  4.35k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 2.91k, False: 1.44k]
  ------------------
   54|  2.91k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 2.89k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|  2.91k|         }
   58|  1.44k|         return m( true );
   59|  1.46k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  44.0k|      {
   50|  44.0k|         auto m = in.template mark< M >();
   51|  44.0k|         using m_t = decltype( m );
   52|       |
   53|   132k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 88.0k, False: 44.0k]
  ------------------
   54|  88.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 88.0k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|  88.0k|         }
   58|  44.0k|         return m( true );
   59|  44.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   161k|      {
   50|   161k|         auto m = in.template mark< M >();
   51|   161k|         using m_t = decltype( m );
   52|       |
   53|   481k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 321k, False: 159k]
  ------------------
   54|   321k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 2.07k, False: 319k]
  ------------------
   55|  2.07k|               return false;
   56|  2.07k|            }
   57|   321k|         }
   58|   159k|         return m( true );
   59|   161k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   319k|      {
   50|   319k|         auto m = in.template mark< M >();
   51|   319k|         using m_t = decltype( m );
   52|       |
   53|   657k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 488k, False: 168k]
  ------------------
   54|   488k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 150k, False: 337k]
  ------------------
   55|   150k|               return false;
   56|   150k|            }
   57|   488k|         }
   58|   168k|         return m( true );
   59|   319k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  24.5k|      {
   50|  24.5k|         auto m = in.template mark< M >();
   51|  24.5k|         using m_t = decltype( m );
   52|       |
   53|  73.6k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 49.0k, False: 24.5k]
  ------------------
   54|  49.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 37, False: 49.0k]
  ------------------
   55|     37|               return false;
   56|     37|            }
   57|  49.0k|         }
   58|  24.5k|         return m( true );
   59|  24.5k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  38.3k|      {
   50|  38.3k|         auto m = in.template mark< M >();
   51|  38.3k|         using m_t = decltype( m );
   52|       |
   53|   115k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 76.7k, False: 38.3k]
  ------------------
   54|  76.7k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 51, False: 76.6k]
  ------------------
   55|     51|               return false;
   56|     51|            }
   57|  76.7k|         }
   58|  38.3k|         return m( true );
   59|  38.3k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  54.0k|      {
   50|  54.0k|         auto m = in.template mark< M >();
   51|  54.0k|         using m_t = decltype( m );
   52|       |
   53|   162k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 108k, False: 54.0k]
  ------------------
   54|   108k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 39, False: 108k]
  ------------------
   55|     39|               return false;
   56|     39|            }
   57|   108k|         }
   58|  54.0k|         return m( true );
   59|  54.0k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  44.9k|      {
   50|  53.8k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 50.3k, False: 3.51k]
  |  Branch (50:47): [True: 8.92k, False: 41.3k]
  ------------------
   51|  8.92k|         }
   52|  44.9k|         return true;
   53|  44.9k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  32.4k|      {
   50|  39.2k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 36.3k, False: 2.91k]
  |  Branch (50:47): [True: 6.76k, False: 29.5k]
  ------------------
   51|  6.76k|         }
   52|  32.4k|         return true;
   53|  32.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  14.7k|      {
   50|  24.9k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 20.4k, False: 4.48k]
  |  Branch (50:47): [True: 10.2k, False: 10.2k]
  ------------------
   51|  10.2k|         }
   52|  14.7k|         return true;
   53|  14.7k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.00k|      {
   50|  1.64k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 1.34k, False: 297]
  |  Branch (50:47): [True: 639, False: 710]
  ------------------
   51|    639|         }
   52|  1.00k|         return true;
   53|  1.00k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  30.8k|      {
   50|  46.8k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 40.2k, False: 6.63k]
  |  Branch (50:47): [True: 16.0k, False: 24.1k]
  ------------------
   51|  16.0k|         }
   52|  30.8k|         return true;
   53|  30.8k|      }
_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|  34.1k|      {
   50|  39.9k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 38.6k, False: 1.26k]
  |  Branch (50:47): [True: 5.78k, False: 32.9k]
  ------------------
   51|  5.78k|         }
   52|  34.1k|         return true;
   53|  34.1k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  29.1k|      {
   50|  37.2k|         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: 2.65k]
  |  Branch (50:47): [True: 8.13k, False: 26.4k]
  ------------------
   51|  8.13k|         }
   52|  29.1k|         return true;
   53|  29.1k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  81.1k|      {
   50|  95.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 89.3k, False: 6.44k]
  |  Branch (50:47): [True: 14.6k, False: 74.6k]
  ------------------
   51|  14.6k|         }
   52|  81.1k|         return true;
   53|  81.1k|      }

_ZN3tao5pegtl8internal3seqIJNS0_4starINS0_5ascii5blankEJEEENS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENSA_4ruleEEEEEEENS0_4mustIJNS0_3eofEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSS_11char_traitsIcEENSS_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   41|  43.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.6k|         else {
   46|  43.6k|            auto m = in.template mark< M >();
   47|  43.6k|            using m_t = decltype( m );
   48|   170k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 39.0k, False: 4.66k]
  |  Branch (48:25): [True: 34.4k, False: 4.57k]
  |  Branch (48:25): [True: 43.6k, False: 0]
  ------------------
   49|  43.6k|         }
   50|  43.6k|      }
_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|  82.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  82.5k|         else {
   46|  82.5k|            auto m = in.template mark< M >();
   47|  82.5k|            using m_t = decltype( m );
   48|   165k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 82.5k, False: 0]
  |  Branch (48:25): [True: 13.7k, False: 68.8k]
  ------------------
   49|  82.5k|         }
   50|  82.5k|      }
_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|   865k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   865k|         else {
   46|   865k|            auto m = in.template mark< M >();
   47|   865k|            using m_t = decltype( m );
   48|  1.71M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 851k, False: 13.7k]
  |  Branch (48:25): [True: 851k, False: 0]
  ------------------
   49|   865k|         }
   50|   865k|      }
_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|  43.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.6k|         else {
   46|  43.6k|            auto m = in.template mark< M >();
   47|  43.6k|            using m_t = decltype( m );
   48|   334k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 38.8k, False: 0]
  |  Branch (48:25): [True: 38.8k, False: 0]
  |  Branch (48:25): [True: 38.8k, False: 4.66k]
  |  Branch (48:25): [True: 43.5k, False: 6]
  |  Branch (48:25): [True: 43.5k, False: 106]
  ------------------
   49|  43.6k|         }
   50|  43.6k|      }
_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|  43.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.5k|         else {
   46|  43.5k|            auto m = in.template mark< M >();
   47|  43.5k|            using m_t = decltype( m );
   48|  87.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 43.5k, False: 25]
  |  Branch (48:25): [True: 2.77k, False: 40.7k]
  ------------------
   49|  43.5k|         }
   50|  43.5k|      }
_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|  43.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.5k|         else {
   46|  43.5k|            auto m = in.template mark< M >();
   47|  43.5k|            using m_t = decltype( m );
   48|  51.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.79k, False: 25]
  |  Branch (48:25): [True: 2.78k, False: 10]
  |  Branch (48:25): [True: 2.81k, False: 40.7k]
  ------------------
   49|  43.5k|         }
   50|  43.5k|      }
_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|  43.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.5k|         else {
   46|  43.5k|            auto m = in.template mark< M >();
   47|  43.5k|            using m_t = decltype( m );
   48|  85.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 41.9k, False: 1.60k]
  |  Branch (48:25): [True: 29.5k, False: 12.4k]
  ------------------
   49|  43.5k|         }
   50|  43.5k|      }
_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|  41.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  41.9k|         else {
   46|  41.9k|            auto m = in.template mark< M >();
   47|  41.9k|            using m_t = decltype( m );
   48|  71.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 29.8k, False: 12.1k]
  |  Branch (48:25): [True: 29.5k, False: 294]
  ------------------
   49|  41.9k|         }
   50|  41.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|  48.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  48.0k|         else {
   46|  48.0k|            auto m = in.template mark< M >();
   47|  48.0k|            using m_t = decltype( m );
   48|  59.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.81k, False: 19]
  |  Branch (48:25): [True: 3.34k, False: 470]
  |  Branch (48:25): [True: 3.83k, False: 44.1k]
  ------------------
   49|  48.0k|         }
   50|  48.0k|      }
_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.81k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.81k|         else {
   46|  3.81k|            auto m = in.template mark< M >();
   47|  3.81k|            using m_t = decltype( m );
   48|  27.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.27k, False: 0]
  |  Branch (48:25): [True: 2.09k, False: 177]
  |  Branch (48:25): [True: 2.27k, False: 62]
  |  Branch (48:25): [True: 2.33k, False: 0]
  |  Branch (48:25): [True: 2.33k, False: 1.47k]
  |  Branch (48:25): [True: 3.81k, False: 0]
  ------------------
   49|  3.81k|         }
   50|  3.81k|      }
_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.81k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.81k|         else {
   46|  3.81k|            auto m = in.template mark< M >();
   47|  3.81k|            using m_t = decltype( m );
   48|  5.54k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.73k, False: 2.08k]
  |  Branch (48:25): [True: 1.69k, False: 40]
  ------------------
   49|  3.81k|         }
   50|  3.81k|      }
_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.33k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.33k|         else {
   46|  2.33k|            auto m = in.template mark< M >();
   47|  2.33k|            using m_t = decltype( m );
   48|  4.61k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.27k, False: 60]
  |  Branch (48:25): [True: 2.27k, False: 2]
  ------------------
   49|  2.33k|         }
   50|  2.33k|      }
_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|   803k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   803k|         else {
   46|   803k|            auto m = in.template mark< M >();
   47|   803k|            using m_t = decltype( m );
   48|  1.60M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 802k, False: 1.18k]
  |  Branch (48:25): [True: 801k, False: 1.09k]
  ------------------
   49|   803k|         }
   50|   803k|      }
_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|   806k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   806k|         else {
   46|   806k|            auto m = in.template mark< M >();
   47|   806k|            using m_t = decltype( m );
   48|  3.22M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 804k, False: 42]
  |  Branch (48:25): [True: 804k, False: 22]
  |  Branch (48:25): [True: 804k, False: 1.54k]
  ------------------
   49|   806k|         }
   50|   806k|      }
_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|  44.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  44.6k|         else {
   46|  44.6k|            auto m = in.template mark< M >();
   47|  44.6k|            using m_t = decltype( m );
   48|  57.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.24k, False: 16]
  |  Branch (48:25): [True: 3.52k, False: 721]
  |  Branch (48:25): [True: 4.25k, False: 40.4k]
  ------------------
   49|  44.6k|         }
   50|  44.6k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.24k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.24k|         else {
   46|  4.24k|            auto m = in.template mark< M >();
   47|  4.24k|            using m_t = decltype( m );
   48|  34.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.03k, False: 0]
  |  Branch (48:25): [True: 2.90k, False: 133]
  |  Branch (48:25): [True: 3.03k, False: 70]
  |  Branch (48:25): [True: 3.10k, False: 0]
  |  Branch (48:25): [True: 3.10k, False: 1.13k]
  |  Branch (48:25): [True: 4.24k, False: 0]
  ------------------
   49|  4.24k|         }
   50|  4.24k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.24k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.24k|         else {
   46|  4.24k|            auto m = in.template mark< M >();
   47|  4.24k|            using m_t = decltype( m );
   48|  6.17k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.92k, False: 2.31k]
  |  Branch (48:25): [True: 1.88k, False: 41]
  ------------------
   49|  4.24k|         }
   50|  4.24k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.10k|         else {
   46|  3.10k|            auto m = in.template mark< M >();
   47|  3.10k|            using m_t = decltype( m );
   48|  6.16k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.05k, False: 55]
  |  Branch (48:25): [True: 3.03k, False: 15]
  ------------------
   49|  3.10k|         }
   50|  3.10k|      }
_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|   457k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   457k|         else {
   46|   457k|            auto m = in.template mark< M >();
   47|   457k|            using m_t = decltype( m );
   48|   912k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 455k, False: 2.35k]
  |  Branch (48:25): [True: 454k, False: 694]
  ------------------
   49|   457k|         }
   50|   457k|      }
_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|  40.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  40.7k|         else {
   46|  40.7k|            auto m = in.template mark< M >();
   47|  40.7k|            using m_t = decltype( m );
   48|  54.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.47k, False: 19]
  |  Branch (48:25): [True: 3.73k, False: 737]
  |  Branch (48:25): [True: 4.49k, False: 36.2k]
  ------------------
   49|  40.7k|         }
   50|  40.7k|      }
_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.47k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.47k|         else {
   46|  4.47k|            auto m = in.template mark< M >();
   47|  4.47k|            using m_t = decltype( m );
   48|  35.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.11k, False: 0]
  |  Branch (48:25): [True: 2.96k, False: 147]
  |  Branch (48:25): [True: 3.11k, False: 89]
  |  Branch (48:25): [True: 3.20k, False: 0]
  |  Branch (48:25): [True: 3.20k, False: 1.27k]
  |  Branch (48:25): [True: 4.47k, False: 0]
  ------------------
   49|  4.47k|         }
   50|  4.47k|      }
_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.47k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.47k|         else {
   46|  4.47k|            auto m = in.template mark< M >();
   47|  4.47k|            using m_t = decltype( m );
   48|  6.69k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.22k, False: 2.25k]
  |  Branch (48:25): [True: 2.18k, False: 40]
  ------------------
   49|  4.47k|         }
   50|  4.47k|      }
_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|  3.20k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.20k|         else {
   46|  3.20k|            auto m = in.template mark< M >();
   47|  3.20k|            using m_t = decltype( m );
   48|  6.33k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.13k, False: 69]
  |  Branch (48:25): [True: 3.11k, False: 20]
  ------------------
   49|  3.20k|         }
   50|  3.20k|      }
_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.55k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.55k|         else {
   46|  6.55k|            auto m = in.template mark< M >();
   47|  6.55k|            using m_t = decltype( m );
   48|  10.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.25k, False: 2.30k]
  |  Branch (48:25): [True: 3.42k, False: 831]
  ------------------
   49|  6.55k|         }
   50|  6.55k|      }
_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|  36.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  36.6k|         else {
   46|  36.6k|            auto m = in.template mark< M >();
   47|  36.6k|            using m_t = decltype( m );
   48|  46.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.15k, False: 15]
  |  Branch (48:25): [True: 2.54k, False: 616]
  |  Branch (48:25): [True: 3.17k, False: 33.4k]
  ------------------
   49|  36.6k|         }
   50|  36.6k|      }
_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.15k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.15k|         else {
   46|  3.15k|            auto m = in.template mark< M >();
   47|  3.15k|            using m_t = decltype( m );
   48|  24.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.04k, False: 0]
  |  Branch (48:25): [True: 1.92k, False: 122]
  |  Branch (48:25): [True: 2.04k, False: 62]
  |  Branch (48:25): [True: 2.10k, False: 0]
  |  Branch (48:25): [True: 2.10k, False: 1.05k]
  |  Branch (48:25): [True: 3.15k, False: 0]
  ------------------
   49|  3.15k|         }
   50|  3.15k|      }
_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.15k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.15k|         else {
   46|  3.15k|            auto m = in.template mark< M >();
   47|  3.15k|            using m_t = decltype( m );
   48|  4.31k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.16k, False: 1.99k]
  |  Branch (48:25): [True: 1.11k, False: 48]
  ------------------
   49|  3.15k|         }
   50|  3.15k|      }
_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.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.10k|         else {
   46|  2.10k|            auto m = in.template mark< M >();
   47|  2.10k|            using m_t = decltype( m );
   48|  4.16k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.05k, False: 51]
  |  Branch (48:25): [True: 2.04k, False: 11]
  ------------------
   49|  2.10k|         }
   50|  2.10k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.93k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.93k|         else {
   46|  4.93k|            auto m = in.template mark< M >();
   47|  4.93k|            using m_t = decltype( m );
   48|  8.31k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.38k, False: 1.55k]
  |  Branch (48:25): [True: 2.87k, False: 505]
  ------------------
   49|  4.93k|         }
   50|  4.93k|      }
_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|  33.8k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  33.8k|         else {
   46|  33.8k|            auto m = in.template mark< M >();
   47|  33.8k|            using m_t = decltype( m );
   48|  44.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.55k, False: 16]
  |  Branch (48:25): [True: 3.08k, False: 466]
  |  Branch (48:25): [True: 3.57k, False: 30.2k]
  ------------------
   49|  33.8k|         }
   50|  33.8k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.55k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.55k|         else {
   46|  3.55k|            auto m = in.template mark< M >();
   47|  3.55k|            using m_t = decltype( m );
   48|  25.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.04k, False: 0]
  |  Branch (48:25): [True: 1.94k, False: 103]
  |  Branch (48:25): [True: 2.04k, False: 43]
  |  Branch (48:25): [True: 2.08k, False: 0]
  |  Branch (48:25): [True: 2.08k, False: 1.46k]
  |  Branch (48:25): [True: 3.55k, False: 0]
  ------------------
   49|  3.55k|         }
   50|  3.55k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.55k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.55k|         else {
   46|  3.55k|            auto m = in.template mark< M >();
   47|  3.55k|            using m_t = decltype( m );
   48|  5.11k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.55k, False: 1.99k]
  |  Branch (48:25): [True: 1.52k, False: 30]
  ------------------
   49|  3.55k|         }
   50|  3.55k|      }
_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|  2.08k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.08k|         else {
   46|  2.08k|            auto m = in.template mark< M >();
   47|  2.08k|            using m_t = decltype( m );
   48|  4.13k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.05k, False: 34]
  |  Branch (48:25): [True: 2.04k, False: 9]
  ------------------
   49|  2.08k|         }
   50|  2.08k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.21k|         else {
   46|  4.21k|            auto m = in.template mark< M >();
   47|  4.21k|            using m_t = decltype( m );
   48|  6.69k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.48k, False: 1.73k]
  |  Branch (48:25): [True: 2.16k, False: 322]
  ------------------
   49|  4.21k|         }
   50|  4.21k|      }
_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|  30.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  30.4k|         else {
   46|  30.4k|            auto m = in.template mark< M >();
   47|  30.4k|            using m_t = decltype( m );
   48|  42.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.10k, False: 19]
  |  Branch (48:25): [True: 3.42k, False: 683]
  |  Branch (48:25): [True: 4.12k, False: 26.3k]
  ------------------
   49|  30.4k|         }
   50|  30.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.10k|         else {
   46|  4.10k|            auto m = in.template mark< M >();
   47|  4.10k|            using m_t = decltype( m );
   48|  32.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.78k, False: 0]
  |  Branch (48:25): [True: 2.64k, False: 138]
  |  Branch (48:25): [True: 2.78k, False: 75]
  |  Branch (48:25): [True: 2.85k, False: 0]
  |  Branch (48:25): [True: 2.85k, False: 1.24k]
  |  Branch (48:25): [True: 4.10k, False: 0]
  ------------------
   49|  4.10k|         }
   50|  4.10k|      }
_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|  4.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.10k|         else {
   46|  4.10k|            auto m = in.template mark< M >();
   47|  4.10k|            using m_t = decltype( m );
   48|  5.72k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.62k, False: 2.48k]
  |  Branch (48:25): [True: 1.57k, False: 45]
  ------------------
   49|  4.10k|         }
   50|  4.10k|      }
_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.85k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.85k|         else {
   46|  2.85k|            auto m = in.template mark< M >();
   47|  2.85k|            using m_t = decltype( m );
   48|  5.65k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.79k, False: 65]
  |  Branch (48:25): [True: 2.78k, False: 10]
  ------------------
   49|  2.85k|         }
   50|  2.85k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  5.49k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.49k|         else {
   46|  5.49k|            auto m = in.template mark< M >();
   47|  5.49k|            using m_t = decltype( m );
   48|  9.24k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.74k, False: 1.75k]
  |  Branch (48:25): [True: 2.70k, False: 1.04k]
  ------------------
   49|  5.49k|         }
   50|  5.49k|      }
_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|  26.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  26.7k|         else {
   46|  26.7k|            auto m = in.template mark< M >();
   47|  26.7k|            using m_t = decltype( m );
   48|  41.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.83k, False: 7]
  |  Branch (48:25): [True: 4.38k, False: 446]
  |  Branch (48:25): [True: 4.84k, False: 21.8k]
  ------------------
   49|  26.7k|         }
   50|  26.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15interface_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.83k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.83k|         else {
   46|  4.83k|            auto m = in.template mark< M >();
   47|  4.83k|            using m_t = decltype( m );
   48|  42.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.90k, False: 0]
  |  Branch (48:25): [True: 3.72k, False: 187]
  |  Branch (48:25): [True: 3.90k, False: 56]
  |  Branch (48:25): [True: 3.96k, False: 0]
  |  Branch (48:25): [True: 3.96k, False: 872]
  |  Branch (48:25): [True: 4.83k, False: 0]
  ------------------
   49|  4.83k|         }
   50|  4.83k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.83k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.83k|         else {
   46|  4.83k|            auto m = in.template mark< M >();
   47|  4.83k|            using m_t = decltype( m );
   48|  8.25k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.42k, False: 1.41k]
  |  Branch (48:25): [True: 3.38k, False: 37]
  ------------------
   49|  4.83k|         }
   50|  4.83k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15interface_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.96k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.96k|         else {
   46|  3.96k|            auto m = in.template mark< M >();
   47|  3.96k|            using m_t = decltype( m );
   48|  7.87k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.90k, False: 54]
  |  Branch (48:25): [True: 3.90k, False: 2]
  ------------------
   49|  3.96k|         }
   50|  3.96k|      }
_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|   158k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   158k|         else {
   46|   158k|            auto m = in.template mark< M >();
   47|   158k|            using m_t = decltype( m );
   48|   315k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 156k, False: 2.20k]
  |  Branch (48:25): [True: 154k, False: 1.70k]
  ------------------
   49|   158k|         }
   50|   158k|      }
_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|   161k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   161k|         else {
   46|   161k|            auto m = in.template mark< M >();
   47|   161k|            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: 159k, False: 21]
  |  Branch (48:25): [True: 159k, False: 27]
  |  Branch (48:25): [True: 159k, False: 31]
  |  Branch (48:25): [True: 159k, False: 40]
  |  Branch (48:25): [True: 159k, False: 2.07k]
  ------------------
   49|   161k|         }
   50|   161k|      }
_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|  22.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  22.3k|         else {
   46|  22.3k|            auto m = in.template mark< M >();
   47|  22.3k|            using m_t = decltype( m );
   48|  31.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.07k, False: 9]
  |  Branch (48:25): [True: 2.47k, False: 598]
  |  Branch (48:25): [True: 3.08k, False: 19.2k]
  ------------------
   49|  22.3k|         }
   50|  22.3k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.07k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.07k|         else {
   46|  3.07k|            auto m = in.template mark< M >();
   47|  3.07k|            using m_t = decltype( m );
   48|  26.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.44k, False: 0]
  |  Branch (48:25): [True: 2.32k, False: 126]
  |  Branch (48:25): [True: 2.44k, False: 85]
  |  Branch (48:25): [True: 2.53k, False: 0]
  |  Branch (48:25): [True: 2.53k, False: 540]
  |  Branch (48:25): [True: 3.07k, False: 0]
  ------------------
   49|  3.07k|         }
   50|  3.07k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.07k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.07k|         else {
   46|  3.07k|            auto m = in.template mark< M >();
   47|  3.07k|            using m_t = decltype( m );
   48|  4.38k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.31k, False: 1.75k]
  |  Branch (48:25): [True: 1.27k, False: 39]
  ------------------
   49|  3.07k|         }
   50|  3.07k|      }
_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.53k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.53k|         else {
   46|  2.53k|            auto m = in.template mark< M >();
   47|  2.53k|            using m_t = decltype( m );
   48|  4.99k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.46k, False: 71]
  |  Branch (48:25): [True: 2.44k, False: 14]
  ------------------
   49|  2.53k|         }
   50|  2.53k|      }
_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.77k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.77k|         else {
   46|  4.77k|            auto m = in.template mark< M >();
   47|  4.77k|            using m_t = decltype( m );
   48|  7.65k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.88k, False: 1.88k]
  |  Branch (48:25): [True: 2.30k, False: 575]
  ------------------
   49|  4.77k|         }
   50|  4.77k|      }
_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|  19.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  19.5k|         else {
   46|  19.5k|            auto m = in.template mark< M >();
   47|  19.5k|            using m_t = decltype( m );
   48|  38.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.21k, False: 27]
  |  Branch (48:25): [True: 3.14k, False: 3.07k]
  |  Branch (48:25): [True: 6.24k, False: 13.3k]
  ------------------
   49|  19.5k|         }
   50|  19.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|  6.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.21k|         else {
   46|  6.21k|            auto m = in.template mark< M >();
   47|  6.21k|            using m_t = decltype( m );
   48|  41.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: 1.91k, False: 637]
  |  Branch (48:25): [True: 2.55k, False: 1.23k]
  |  Branch (48:25): [True: 3.78k, False: 0]
  |  Branch (48:25): [True: 3.78k, False: 2.43k]
  |  Branch (48:25): [True: 6.21k, False: 0]
  ------------------
   49|  6.21k|         }
   50|  6.21k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  6.21k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.21k|         else {
   46|  6.21k|            auto m = in.template mark< M >();
   47|  6.21k|            using m_t = decltype( m );
   48|  7.56k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.34k, False: 4.87k]
  |  Branch (48:25): [True: 1.26k, False: 80]
  ------------------
   49|  6.21k|         }
   50|  6.21k|      }
_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.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|  7.44k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.65k, False: 131]
  |  Branch (48:25): [True: 2.55k, False: 1.10k]
  ------------------
   49|  3.78k|         }
   50|  3.78k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   644k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   644k|         else {
   46|   644k|            auto m = in.template mark< M >();
   47|   644k|            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: 642k, False: 2.23k]
  |  Branch (48:25): [True: 640k, False: 1.42k]
  ------------------
   49|   644k|         }
   50|   644k|      }
_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|   649k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   649k|         else {
   46|   649k|            auto m = in.template mark< M >();
   47|   649k|            using m_t = decltype( m );
   48|  2.59M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 647k, False: 1.10k]
  |  Branch (48:25): [True: 647k, False: 397]
  |  Branch (48:25): [True: 649k, False: 0]
  ------------------
   49|   649k|         }
   50|   649k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   649k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   649k|         else {
   46|   649k|            auto m = in.template mark< M >();
   47|   649k|            using m_t = decltype( m );
   48|  1.29M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 647k, False: 1.10k]
  |  Branch (48:25): [True: 647k, False: 0]
  ------------------
   49|   649k|         }
   50|   649k|      }
_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|  14.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  14.0k|         else {
   46|  14.0k|            auto m = in.template mark< M >();
   47|  14.0k|            using m_t = decltype( m );
   48|  26.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.03k, False: 21]
  |  Branch (48:25): [True: 3.33k, False: 701]
  |  Branch (48:25): [True: 4.05k, False: 10.0k]
  ------------------
   49|  14.0k|         }
   50|  14.0k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.03k|         else {
   46|  4.03k|            auto m = in.template mark< M >();
   47|  4.03k|            using m_t = decltype( m );
   48|  27.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.19k, False: 0]
  |  Branch (48:25): [True: 2.07k, False: 119]
  |  Branch (48:25): [True: 2.19k, False: 90]
  |  Branch (48:25): [True: 2.28k, False: 0]
  |  Branch (48:25): [True: 2.28k, False: 1.74k]
  |  Branch (48:25): [True: 4.03k, False: 0]
  ------------------
   49|  4.03k|         }
   50|  4.03k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.03k|         else {
   46|  4.03k|            auto m = in.template mark< M >();
   47|  4.03k|            using m_t = decltype( m );
   48|  5.42k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.39k, False: 2.63k]
  |  Branch (48:25): [True: 1.33k, False: 59]
  ------------------
   49|  4.03k|         }
   50|  4.03k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.28k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.28k|         else {
   46|  2.28k|            auto m = in.template mark< M >();
   47|  2.28k|            using m_t = decltype( m );
   48|  4.50k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.21k, False: 73]
  |  Branch (48:25): [True: 2.19k, False: 17]
  ------------------
   49|  2.28k|         }
   50|  2.28k|      }
_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.39k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.39k|         else {
   46|  4.39k|            auto m = in.template mark< M >();
   47|  4.39k|            using m_t = decltype( m );
   48|  7.05k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.66k, False: 1.72k]
  |  Branch (48:25): [True: 2.17k, False: 489]
  ------------------
   49|  4.39k|         }
   50|  4.39k|      }
_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|  32.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  32.9k|         else {
   46|  32.9k|            auto m = in.template mark< M >();
   47|  32.9k|            using m_t = decltype( m );
   48|  39.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.07k, False: 26.9k]
  |  Branch (48:25): [True: 3.17k, False: 2.89k]
  ------------------
   49|  32.9k|         }
   50|  32.9k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  43.6k|      {
   58|  43.6k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  43.6k|      }
_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|  43.6k|      {
   45|  87.3k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 28, False: 43.6k]
  |  Branch (45:19): [True: 43.5k, False: 106]
  ------------------
   46|  43.6k|      }
_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|  43.6k|      {
   58|  43.6k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  43.6k|      }
_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|  43.6k|      {
   45|  55.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 881, False: 144]
  |  Branch (45:19): [True: 38, False: 106]
  |  Branch (45:19): [True: 14, False: 1.02k]
  |  Branch (45:19): [True: 2.84k, False: 1.03k]
  |  Branch (45:19): [True: 39.7k, False: 3.88k]
  ------------------
   46|  43.6k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  46.3k|      {
   58|  46.3k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  46.3k|      }
_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|  46.3k|      {
   45|  89.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.13k, False: 43.1k]
  |  Branch (45:19): [True: 2.45k, False: 40.7k]
  ------------------
   46|  46.3k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser12id_attributeENS4_14name_attributeENS4_14hash_attributeENS4_21parent_hash_attributeENS4_16serial_attributeENS4_18via_port_attributeENS4_24with_interface_attributeENS4_27with_connect_type_attributeENS4_19condition_attributeENS4_15label_attributeEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  48.0k|      {
   58|  48.0k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  48.0k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser12id_attributeENS4_14name_attributeENS4_14hash_attributeENS4_21parent_hash_attributeENS4_16serial_attributeENS4_18via_port_attributeENS4_24with_interface_attributeENS4_27with_connect_type_attributeENS4_19condition_attributeENS4_15label_attributeEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSQ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  48.0k|      {
   45|   572k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 5.48k, False: 14.0k]
  |  Branch (45:19): [True: 3.69k, False: 10.3k]
  |  Branch (45:19): [True: 2.78k, False: 19.5k]
  |  Branch (45:19): [True: 4.39k, False: 22.3k]
  |  Branch (45:19): [True: 3.76k, False: 26.7k]
  |  Branch (45:19): [True: 3.31k, False: 30.4k]
  |  Branch (45:19): [True: 2.85k, False: 33.8k]
  |  Branch (45:19): [True: 4.10k, False: 36.6k]
  |  Branch (45:19): [True: 3.91k, False: 40.7k]
  |  Branch (45:19): [True: 3.35k, False: 44.6k]
  ------------------
   46|  48.0k|      }
_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.81k|      {
   58|  3.81k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.81k|      }
_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.81k|      {
   45|  5.52k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.10k, False: 1.71k]
  |  Branch (45:19): [True: 1.24k, False: 465]
  ------------------
   46|  3.81k|      }
_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.81k|      {
   58|  3.81k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.81k|      }
_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.81k|      {
   45|  31.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 543, False: 2.27k]
  |  Branch (45:19): [True: 196, False: 2.08k]
  |  Branch (45:19): [True: 359, False: 2.82k]
  |  Branch (45:19): [True: 194, False: 3.17k]
  |  Branch (45:19): [True: 210, False: 3.37k]
  |  Branch (45:19): [True: 228, False: 3.58k]
  ------------------
   46|  3.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.61M|      {
   58|  1.61M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.61M|      }
_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.61M|      {
   45|  3.22M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.59k, False: 1.60M]
  |  Branch (45:19): [True: 1.60M, False: 1.57k]
  ------------------
   46|  1.61M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.24k|      {
   58|  4.24k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.24k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.24k|      {
   45|  5.54k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.93k, False: 1.30k]
  |  Branch (45:19): [True: 974, False: 333]
  ------------------
   46|  4.24k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.24k|      {
   58|  4.24k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.24k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.24k|      {
   45|  33.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 356, False: 2.50k]
  |  Branch (45:19): [True: 195, False: 2.31k]
  |  Branch (45:19): [True: 194, False: 2.86k]
  |  Branch (45:19): [True: 496, False: 3.05k]
  |  Branch (45:19): [True: 305, False: 3.55k]
  |  Branch (45:19): [True: 383, False: 3.85k]
  ------------------
   46|  4.24k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  16.3M|      {
   58|  16.3M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  16.3M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  16.3M|      {
   45|  32.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 244k, False: 16.0M]
  |  Branch (45:19): [True: 16.0M, False: 217]
  ------------------
   46|  16.3M|      }
_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|   244k|      {
   58|   244k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   244k|      }
_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|   244k|      {
   45|   732k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 93.8k, False: 4.57k]
  |  Branch (45:19): [True: 4.52k, False: 57]
  |  Branch (45:19): [True: 44.9k, False: 98.4k]
  |  Branch (45:19): [True: 100k, False: 143k]
  ------------------
   46|   244k|      }
_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.47k|      {
   58|  4.47k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.47k|      }
_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.47k|      {
   45|  5.94k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.00k, False: 1.46k]
  |  Branch (45:19): [True: 1.09k, False: 373]
  ------------------
   46|  4.47k|      }
_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.47k|      {
   58|  4.47k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.47k|      }
_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.47k|      {
   45|  34.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 252, False: 2.67k]
  |  Branch (45:19): [True: 428, False: 2.25k]
  |  Branch (45:19): [True: 198, False: 2.93k]
  |  Branch (45:19): [True: 349, False: 3.12k]
  |  Branch (45:19): [True: 648, False: 3.47k]
  |  Branch (45:19): [True: 349, False: 4.12k]
  ------------------
   46|  4.47k|      }
_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|  6.90M|      {
   58|  6.90M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.90M|      }
_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|  6.90M|      {
   45|  13.7M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 76.3k, False: 6.83M]
  |  Branch (45:19): [True: 6.83M, False: 208]
  ------------------
   46|  6.90M|      }
_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|  76.3k|      {
   58|  76.3k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  76.3k|      }
_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|  76.3k|      {
   45|   235k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 23.1k, False: 359]
  |  Branch (45:19): [True: 301, False: 58]
  |  Branch (45:19): [True: 32.4k, False: 23.4k]
  |  Branch (45:19): [True: 20.4k, False: 55.9k]
  ------------------
   46|  76.3k|      }
_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.15k|      {
   58|  3.15k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.15k|      {
   45|  4.37k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.94k, False: 1.21k]
  |  Branch (45:19): [True: 904, False: 309]
  ------------------
   46|  3.15k|      }
_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.15k|      {
   58|  3.15k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.15k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.15k|      {
   45|  26.3k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 271, False: 2.07k]
  |  Branch (45:19): [True: 82, False: 1.99k]
  |  Branch (45:19): [True: 195, False: 2.34k]
  |  Branch (45:19): [True: 195, False: 2.54k]
  |  Branch (45:19): [True: 199, False: 2.73k]
  |  Branch (45:19): [True: 220, False: 2.93k]
  ------------------
   46|  3.15k|      }
_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|  6.02M|      {
   58|  6.02M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.02M|      }
_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|  6.02M|      {
   45|  11.9M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 85.9k, False: 5.93M]
  |  Branch (45:19): [True: 5.93M, False: 183]
  ------------------
   46|  6.02M|      }
_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|  85.9k|      {
   58|  85.9k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  85.9k|      }
_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|  85.9k|      {
   45|   249k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 32.6k, False: 696]
  |  Branch (45:19): [True: 645, False: 51]
  |  Branch (45:19): [True: 14.7k, False: 33.3k]
  |  Branch (45:19): [True: 37.8k, False: 48.1k]
  ------------------
   46|  85.9k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.55k|      {
   58|  3.55k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.55k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.55k|      {
   45|  5.15k|         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.59k]
  |  Branch (45:19): [True: 1.35k, False: 242]
  ------------------
   46|  3.55k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.55k|      {
   58|  3.55k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.55k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.55k|      {
   45|  29.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 383, False: 2.19k]
  |  Branch (45:19): [True: 201, False: 1.99k]
  |  Branch (45:19): [True: 332, False: 2.57k]
  |  Branch (45:19): [True: 205, False: 2.91k]
  |  Branch (45:19): [True: 202, False: 3.11k]
  |  Branch (45:19): [True: 236, False: 3.31k]
  ------------------
   46|  3.55k|      }
_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.38M|      {
   58|  2.38M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.38M|      }
_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.38M|      {
   45|  4.75M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 5.35k, False: 2.37M]
  |  Branch (45:19): [True: 2.37M, False: 162]
  ------------------
   46|  2.38M|      }
_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.35k|      {
   58|  5.35k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.35k|      }
_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.35k|      {
   45|  19.1k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.64k, False: 245]
  |  Branch (45:19): [True: 221, False: 24]
  |  Branch (45:19): [True: 1.00k, False: 2.88k]
  |  Branch (45:19): [True: 1.46k, False: 3.89k]
  ------------------
   46|  5.35k|      }
_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|  4.10k|      {
   58|  4.10k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.10k|      {
   45|  5.53k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.67k, False: 1.43k]
  |  Branch (45:19): [True: 1.08k, False: 347]
  ------------------
   46|  4.10k|      }
_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|  4.10k|      {
   58|  4.10k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.10k|      {
   45|  35.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 429, False: 2.68k]
  |  Branch (45:19): [True: 197, False: 2.48k]
  |  Branch (45:19): [True: 362, False: 3.10k]
  |  Branch (45:19): [True: 194, False: 3.47k]
  |  Branch (45:19): [True: 223, False: 3.66k]
  |  Branch (45:19): [True: 217, False: 3.88k]
  ------------------
   46|  4.10k|      }
_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|  8.10M|      {
   58|  8.10M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  8.10M|      }
_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|  8.10M|      {
   45|  16.1M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 106k, False: 8.00M]
  |  Branch (45:19): [True: 8.00M, False: 200]
  ------------------
   46|  8.10M|      }
_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|   106k|      {
   58|   106k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   106k|      }
_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|   106k|      {
   45|   295k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 31.2k, False: 524]
  |  Branch (45:19): [True: 460, False: 64]
  |  Branch (45:19): [True: 30.8k, False: 31.7k]
  |  Branch (45:19): [True: 44.0k, False: 62.6k]
  ------------------
   46|   106k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.83k|      {
   58|  4.83k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.83k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.83k|      {
   45|  5.94k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.72k, False: 1.11k]
  |  Branch (45:19): [True: 670, False: 441]
  ------------------
   46|  4.83k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.83k|      {
   58|  4.83k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.83k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.83k|      {
   45|  33.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 390, False: 2.47k]
  |  Branch (45:19): [True: 1.06k, False: 1.41k]
  |  Branch (45:19): [True: 236, False: 2.86k]
  |  Branch (45:19): [True: 308, False: 3.10k]
  |  Branch (45:19): [True: 351, False: 3.41k]
  |  Branch (45:19): [True: 1.07k, False: 3.76k]
  ------------------
   46|  4.83k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   319k|      {
   58|   319k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   319k|      }
_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|   319k|      {
   45|   469k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 168k, False: 150k]
  |  Branch (45:19): [True: 150k, False: 58]
  ------------------
   46|   319k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.07k|      {
   58|  3.07k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.07k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.07k|      {
   45|  3.77k|         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: 706]
  |  Branch (45:19): [True: 414, False: 292]
  ------------------
   46|  3.07k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.07k|      {
   58|  3.07k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.07k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.07k|      {
   45|  25.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 256, False: 1.95k]
  |  Branch (45:19): [True: 197, False: 1.75k]
  |  Branch (45:19): [True: 239, False: 2.21k]
  |  Branch (45:19): [True: 321, False: 2.44k]
  |  Branch (45:19): [True: 99, False: 2.77k]
  |  Branch (45:19): [True: 203, False: 2.86k]
  ------------------
   46|  3.07k|      }
_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|  8.25M|      {
   58|  8.25M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  8.25M|      }
_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|  8.25M|      {
   45|  16.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 101k, False: 8.14M]
  |  Branch (45:19): [True: 8.14M, False: 188]
  ------------------
   46|  8.25M|      }
_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|   101k|      {
   58|   101k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   101k|      }
_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|   101k|      {
   45|   343k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 41.7k, False: 1.22k]
  |  Branch (45:19): [True: 1.19k, False: 28]
  |  Branch (45:19): [True: 34.1k, False: 43.0k]
  |  Branch (45:19): [True: 24.5k, False: 77.2k]
  ------------------
   46|   101k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.21k|      {
   58|  6.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.21k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.21k|      {
   45|  9.32k|         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: 3.10k]
  |  Branch (45:19): [True: 2.36k, False: 744]
  ------------------
   46|  6.21k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.21k|      {
   58|  6.21k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.21k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.21k|      {
   45|  57.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 114, False: 5.06k]
  |  Branch (45:19): [True: 196, False: 4.87k]
  |  Branch (45:19): [True: 510, False: 5.18k]
  |  Branch (45:19): [True: 229, False: 5.69k]
  |  Branch (45:19): [True: 256, False: 5.91k]
  |  Branch (45:19): [True: 44, False: 6.17k]
  ------------------
   46|  6.21k|      }
_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|  48.2M|      {
   58|  48.2M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  48.2M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc41EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  48.2M|      {
   45|  96.4M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 148k, False: 48.1M]
  |  Branch (45:19): [True: 48.1M, False: 278]
  ------------------
   46|  48.2M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   148k|      {
   58|   148k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   148k|      }
_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|   148k|      {
   45|   532k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 80.9k, False: 342]
  |  Branch (45:19): [True: 274, False: 68]
  |  Branch (45:19): [True: 29.1k, False: 81.2k]
  |  Branch (45:19): [True: 38.3k, False: 110k]
  ------------------
   46|   148k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.03k|      {
   58|  4.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.03k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.03k|      {
   45|  5.94k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.11k, False: 1.91k]
  |  Branch (45:19): [True: 1.57k, False: 341]
  ------------------
   46|  4.03k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.03k|      {
   58|  4.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.03k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.03k|      {
   45|  34.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 294, False: 2.88k]
  |  Branch (45:19): [True: 251, False: 2.63k]
  |  Branch (45:19): [True: 198, False: 3.18k]
  |  Branch (45:19): [True: 196, False: 3.38k]
  |  Branch (45:19): [True: 248, False: 3.57k]
  |  Branch (45:19): [True: 207, False: 3.82k]
  ------------------
   46|  4.03k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.90M|      {
   58|  9.90M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.90M|      }
_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.90M|      {
   45|  19.6M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 179k, False: 9.72M]
  |  Branch (45:19): [True: 9.72M, False: 202]
  ------------------
   46|  9.90M|      }
_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|   179k|      {
   58|   179k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   179k|      }
_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|   179k|      {
   45|   522k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 43.0k, False: 1.63k]
  |  Branch (45:19): [True: 1.56k, False: 70]
  |  Branch (45:19): [True: 81.1k, False: 44.6k]
  |  Branch (45:19): [True: 54.0k, False: 125k]
  ------------------
   46|   179k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|   165k|      {
   41|   190k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 25.1k, False: 165k]
  ------------------
   42|  25.1k|         }
   43|   165k|         return true;
   44|   165k|      }
_ZN3tao5pegtl8internal4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEbRT3_DpOT4_:
   40|  13.7k|      {
   41|   865k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 851k, False: 13.7k]
  ------------------
   42|   851k|         }
   43|  13.7k|         return true;
   44|  13.7k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.61k|      {
   41|  8.17k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.56k, False: 4.61k]
  ------------------
   42|  3.56k|         }
   43|  4.61k|         return true;
   44|  4.61k|      }
_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.27k|      {
   41|   803k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 801k, False: 2.27k]
  ------------------
   42|   801k|         }
   43|  2.27k|         return true;
   44|  2.27k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.14k|      {
   41|  8.38k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.23k, False: 6.14k]
  ------------------
   42|  2.23k|         }
   43|  6.14k|         return true;
   44|  6.14k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.05k|      {
   41|   457k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 454k, False: 3.05k]
  ------------------
   42|   454k|         }
   43|  3.05k|         return true;
   44|  3.05k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.31k|      {
   41|  8.95k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.63k, False: 6.31k]
  ------------------
   42|  2.63k|         }
   43|  6.31k|         return true;
   44|  6.31k|      }
_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|  3.13k|      {
   41|  6.55k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.42k, False: 3.13k]
  ------------------
   42|  3.42k|         }
   43|  3.13k|         return true;
   44|  3.13k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.15k|      {
   41|  6.19k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.04k, False: 4.15k]
  ------------------
   42|  2.04k|         }
   43|  4.15k|         return true;
   44|  4.15k|      }
_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.05k|      {
   41|  4.93k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.87k, False: 2.05k]
  ------------------
   42|  2.87k|         }
   43|  2.05k|         return true;
   44|  2.05k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.12k|      {
   41|  5.87k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.75k, False: 4.12k]
  ------------------
   42|  1.75k|         }
   43|  4.12k|         return true;
   44|  4.12k|      }
_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|  2.05k|      {
   41|  4.21k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.16k, False: 2.05k]
  ------------------
   42|  2.16k|         }
   43|  2.05k|         return true;
   44|  2.05k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.64k|      {
   41|  9.11k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.47k, False: 5.64k]
  ------------------
   42|  3.47k|         }
   43|  5.64k|         return true;
   44|  5.64k|      }
_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.79k|      {
   41|  5.49k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.70k, False: 2.79k]
  ------------------
   42|  2.70k|         }
   43|  2.79k|         return true;
   44|  2.79k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  7.87k|      {
   41|  13.1k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.29k, False: 7.87k]
  ------------------
   42|  5.29k|         }
   43|  7.87k|         return true;
   44|  7.87k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.90k|      {
   41|   158k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 154k, False: 3.90k]
  ------------------
   42|   154k|         }
   43|  3.90k|         return true;
   44|  3.90k|      }
_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.97k|      {
   41|  8.15k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.18k, False: 4.97k]
  ------------------
   42|  3.18k|         }
   43|  4.97k|         return true;
   44|  4.97k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.46k|      {
   41|  4.77k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.30k, False: 2.46k]
  ------------------
   42|  2.30k|         }
   43|  2.46k|         return true;
   44|  2.46k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.33k|      {
   41|  11.5k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.20k, False: 6.33k]
  ------------------
   42|  5.20k|         }
   43|  6.33k|         return true;
   44|  6.33k|      }
_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.65k|      {
   41|   644k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 640k, False: 3.65k]
  ------------------
   42|   640k|         }
   43|  3.65k|         return true;
   44|  3.65k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   647k|      {
   41|  27.0M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 26.3M, False: 647k]
  ------------------
   42|  26.3M|         }
   43|   647k|         return true;
   44|   647k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.48k|      {
   41|  6.26k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.77k, False: 4.48k]
  ------------------
   42|  1.77k|         }
   43|  4.48k|         return true;
   44|  4.48k|      }
_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.21k|      {
   41|  4.39k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.17k, False: 2.21k]
  ------------------
   42|  2.17k|         }
   43|  2.21k|         return true;
   44|  2.21k|      }
_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|  29.8k|      {
   41|  32.9k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.17k, False: 29.8k]
  ------------------
   42|  3.17k|         }
   43|  29.8k|         return true;
   44|  29.8k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   477k|   {
   24|   477k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   477k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  43.6k|      {
   52|  43.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 43.6k, False: 42]
  ------------------
   53|  43.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 39.7k, False: 3.83k]
  ------------------
   54|  39.7k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  39.7k|               return true;
   56|  39.7k|            }
   57|  43.6k|         }
   58|  3.88k|         return false;
   59|  43.6k|      }
_ZN3tao5pegtl8internal6stringIJLc98ELc108ELc111ELc99ELc107EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  3.88k|      {
   52|  3.88k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 3.83k, False: 42]
  ------------------
   53|  3.83k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.84k, False: 997]
  ------------------
   54|  2.84k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.84k|               return true;
   56|  2.84k|            }
   57|  3.83k|         }
   58|  1.03k|         return false;
   59|  3.88k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.03k|      {
   52|  1.03k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 960, False: 79]
  ------------------
   53|    960|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 14, False: 946]
  ------------------
   54|     14|               bump_help< string >( in, sizeof...( Cs ) );
   55|     14|               return true;
   56|     14|            }
   57|    960|         }
   58|  1.02k|         return false;
   59|  1.03k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.02k|      {
   52|  1.02k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 983, False: 42]
  ------------------
   53|    983|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 881, False: 102]
  ------------------
   54|    881|               bump_help< string >( in, sizeof...( Cs ) );
   55|    881|               return true;
   56|    881|            }
   57|    983|         }
   58|    144|         return false;
   59|  1.02k|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    144|      {
   52|    144|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 66, False: 78]
  ------------------
   53|     66|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 38, False: 28]
  ------------------
   54|     38|               bump_help< string >( in, sizeof...( Cs ) );
   55|     38|               return true;
   56|     38|            }
   57|     66|         }
   58|    106|         return false;
   59|    144|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  48.0k|      {
   52|  48.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 46.0k, False: 1.96k]
  ------------------
   53|  46.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.83k, False: 42.2k]
  ------------------
   54|  3.83k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.83k|               return true;
   56|  3.83k|            }
   57|  46.0k|         }
   58|  44.1k|         return false;
   59|  48.0k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  41.5k|      {
   52|  41.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 33.6k, False: 7.87k]
  ------------------
   53|  33.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.15k, False: 30.4k]
  ------------------
   54|  3.15k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.15k|               return true;
   56|  3.15k|            }
   57|  33.6k|         }
   58|  38.3k|         return false;
   59|  41.5k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  38.3k|      {
   52|  38.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 30.4k, False: 7.87k]
  ------------------
   53|  30.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.74k, False: 27.7k]
  ------------------
   54|  2.74k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.74k|               return true;
   56|  2.74k|            }
   57|  30.4k|         }
   58|  35.6k|         return false;
   59|  38.3k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  35.6k|      {
   52|  35.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 26.5k, False: 9.03k]
  ------------------
   53|  26.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.68k, False: 23.8k]
  ------------------
   54|  2.68k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.68k|               return true;
   56|  2.68k|            }
   57|  26.5k|         }
   58|  32.9k|         return false;
   59|  35.6k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  32.9k|      {
   52|  32.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 17.7k, False: 15.1k]
  ------------------
   53|  17.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.82k, False: 14.9k]
  ------------------
   54|  2.82k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.82k|               return true;
   56|  2.82k|            }
   57|  17.7k|         }
   58|  30.0k|         return false;
   59|  32.9k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.0k|      {
   52|  30.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 22.2k, False: 7.87k]
  ------------------
   53|  22.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.28k, False: 18.9k]
  ------------------
   54|  3.28k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.28k|               return true;
   56|  3.28k|            }
   57|  22.2k|         }
   58|  26.8k|         return false;
   59|  30.0k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  26.8k|      {
   52|  26.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.6k, False: 10.1k]
  ------------------
   53|  16.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.01k, False: 13.6k]
  ------------------
   54|  3.01k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.01k|               return true;
   56|  3.01k|            }
   57|  16.6k|         }
   58|  23.7k|         return false;
   59|  26.8k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  44.6k|      {
   52|  44.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 42.4k, False: 2.18k]
  ------------------
   53|  42.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.26k, False: 38.2k]
  ------------------
   54|  4.26k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.26k|               return true;
   56|  4.26k|            }
   57|  42.4k|         }
   58|  40.4k|         return false;
   59|  44.6k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  40.7k|      {
   52|  40.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 38.5k, False: 2.18k]
  ------------------
   53|  38.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.49k, False: 34.0k]
  ------------------
   54|  4.49k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.49k|               return true;
   56|  4.49k|            }
   57|  38.5k|         }
   58|  36.2k|         return false;
   59|  40.7k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  36.6k|      {
   52|  36.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 30.4k, False: 6.16k]
  ------------------
   53|  30.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.17k, False: 27.3k]
  ------------------
   54|  3.17k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.17k|               return true;
   56|  3.17k|            }
   57|  30.4k|         }
   58|  33.4k|         return false;
   59|  36.6k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  33.8k|      {
   52|  33.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 31.2k, False: 2.56k]
  ------------------
   53|  31.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.57k, False: 27.6k]
  ------------------
   54|  3.57k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.57k|               return true;
   56|  3.57k|            }
   57|  31.2k|         }
   58|  30.2k|         return false;
   59|  33.8k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.4k|      {
   52|  30.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 26.7k, False: 3.72k]
  ------------------
   53|  26.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.12k, False: 22.6k]
  ------------------
   54|  4.12k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.12k|               return true;
   56|  4.12k|            }
   57|  26.7k|         }
   58|  26.3k|         return false;
   59|  30.4k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  26.7k|      {
   52|  26.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 20.5k, False: 6.15k]
  ------------------
   53|  20.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.84k, False: 15.7k]
  ------------------
   54|  4.84k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.84k|               return true;
   56|  4.84k|            }
   57|  20.5k|         }
   58|  21.8k|         return false;
   59|  26.7k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  22.3k|      {
   52|  22.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 15.0k, False: 7.23k]
  ------------------
   53|  15.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.08k, False: 12.0k]
  ------------------
   54|  3.08k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.08k|               return true;
   56|  3.08k|            }
   57|  15.0k|         }
   58|  19.2k|         return false;
   59|  22.3k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  19.5k|      {
   52|  19.5k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 17.5k, False: 1.96k]
  ------------------
   53|  17.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 6.25k, False: 11.3k]
  ------------------
   54|  6.25k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  6.25k|               return true;
   56|  6.25k|            }
   57|  17.5k|         }
   58|  13.2k|         return false;
   59|  19.5k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  14.0k|      {
   52|  14.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 11.7k, False: 2.31k]
  ------------------
   53|  11.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.05k, False: 7.69k]
  ------------------
   54|  4.05k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.05k|               return true;
   56|  4.05k|            }
   57|  11.7k|         }
   58|  10.0k|         return false;
   59|  14.0k|      }

_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   458k|      {
   71|   458k|         auto m = in.template mark< M >();
   72|   458k|         using m_t = decltype( m );
   73|       |
   74|  16.7M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 16.3M, False: 458k]
  ------------------
   75|  16.3M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 217, False: 16.3M]
  ------------------
   76|    217|               return false;
   77|    217|            }
   78|  16.3M|         }
   79|   458k|         return m( true );
   80|   458k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  7.69k|      {
   71|  7.69k|         auto m = in.template mark< M >();
   72|  7.69k|         using m_t = decltype( m );
   73|       |
   74|  6.91M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.90M, False: 7.48k]
  ------------------
   75|  6.90M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 208, False: 6.90M]
  ------------------
   76|    208|               return false;
   77|    208|            }
   78|  6.90M|         }
   79|  7.48k|         return m( true );
   80|  7.69k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.86k|      {
   71|  5.86k|         auto m = in.template mark< M >();
   72|  5.86k|         using m_t = decltype( m );
   73|       |
   74|  6.03M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.02M, False: 5.67k]
  ------------------
   75|  6.02M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 183, False: 6.02M]
  ------------------
   76|    183|               return false;
   77|    183|            }
   78|  6.02M|         }
   79|  5.67k|         return m( true );
   80|  5.86k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.58k|      {
   71|  5.58k|         auto m = in.template mark< M >();
   72|  5.58k|         using m_t = decltype( m );
   73|       |
   74|  2.38M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 2.38M, False: 5.42k]
  ------------------
   75|  2.38M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 162, False: 2.38M]
  ------------------
   76|    162|               return false;
   77|    162|            }
   78|  2.38M|         }
   79|  5.42k|         return m( true );
   80|  5.58k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.61k|      {
   71|  6.61k|         auto m = in.template mark< M >();
   72|  6.61k|         using m_t = decltype( m );
   73|       |
   74|  8.11M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 8.10M, False: 6.41k]
  ------------------
   75|  8.10M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 200, False: 8.10M]
  ------------------
   76|    200|               return false;
   77|    200|            }
   78|  8.10M|         }
   79|  6.41k|         return m( true );
   80|  6.61k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.22k|      {
   71|  5.22k|         auto m = in.template mark< M >();
   72|  5.22k|         using m_t = decltype( m );
   73|       |
   74|  8.25M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 8.25M, False: 5.04k]
  ------------------
   75|  8.25M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 188, False: 8.25M]
  ------------------
   76|    188|               return false;
   77|    188|            }
   78|  8.25M|         }
   79|  5.04k|         return m( true );
   80|  5.22k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  44.7k|      {
   71|  44.7k|         auto m = in.template mark< M >();
   72|  44.7k|         using m_t = decltype( m );
   73|       |
   74|  48.3M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 48.2M, False: 44.4k]
  ------------------
   75|  48.2M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 278, False: 48.2M]
  ------------------
   76|    278|               return false;
   77|    278|            }
   78|  48.2M|         }
   79|  44.4k|         return m( true );
   80|  44.7k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.00k|      {
   71|  6.00k|         auto m = in.template mark< M >();
   72|  6.00k|         using m_t = decltype( m );
   73|       |
   74|  9.90M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.90M, False: 5.80k]
  ------------------
   75|  9.90M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 202, False: 9.90M]
  ------------------
   76|    202|               return false;
   77|    202|            }
   78|  9.90M|         }
   79|  5.80k|         return m( true );
   80|  6.00k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.4k, False: 9.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|  34.4k|            else if constexpr( has_apply0_bool ) {
  153|  34.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.4k|            }
  155|  34.4k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.4k, False: 9.24k]
  ------------------
  157|  34.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.4k|         }
  159|  9.24k|         else {
  160|  9.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.24k|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   44|  43.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.6k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 165k, 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|   165k|            else if constexpr( has_apply0_bool ) {
  153|   165k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   165k|            }
  155|   165k|         }
  156|   165k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 0]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   165k|         (void)m( result );
  163|   165k|         return result;
  164|   165k|      }
  165|   165k|   }
_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|   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_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|   165k|      {
   44|   165k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   165k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   292k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   292k|      else {
  108|   292k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   292k|         using iterator_t = typename ParseInput::iterator_t;
  111|   292k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   292k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   292k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   292k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   292k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   292k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   292k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   292k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   292k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   292k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   292k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   292k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   292k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   292k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   292k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   292k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   292k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   292k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.7k, False: 256k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   292k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.7k, False: 256k]
  ------------------
  157|  35.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.7k|         }
  159|   256k|         else {
  160|   256k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   256k|         }
  162|   292k|         (void)m( result );
  163|   292k|         return result;
  164|   292k|      }
  165|   292k|   }
_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|   292k|      {
   73|   292k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   292k|         else {
   84|   292k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   292k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   292k|      }
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|   292k|      {
   59|   292k|         return Rule::match( in );
   60|   292k|      }
_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|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.0k, False: 4.66k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.0k|            else if constexpr( has_apply0_bool ) {
  153|  39.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.0k|            }
  155|  39.0k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.0k, False: 4.66k]
  ------------------
  157|  39.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.0k|         }
  159|  4.66k|         else {
  160|  4.66k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.66k|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   44|  43.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.6k|      }
_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|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.9k, False: 4.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|  38.9k|            else if constexpr( has_apply0_bool ) {
  153|  38.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.9k|            }
  155|  38.9k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.9k, False: 4.77k]
  ------------------
  157|  38.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.9k|         }
  159|  4.77k|         else {
  160|  4.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.77k|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   44|  43.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  82.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  82.5k|      else {
  108|  82.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  82.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  82.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|  82.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|  82.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|  82.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): [True: 0, Folded]
  ------------------
  116|  82.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|  82.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [True: 82.5k, Folded]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  82.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  82.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  82.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  82.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|  82.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  82.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  82.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|  82.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  82.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  82.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  82.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  82.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.7k, False: 68.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|  13.7k|            else if constexpr( has_apply0_void ) {
  150|  13.7k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  13.7k|         }
  156|  82.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.7k, False: 68.8k]
  ------------------
  157|  13.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.7k|         }
  159|  68.8k|         else {
  160|  68.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.8k|         }
  162|  82.5k|         (void)m( result );
  163|  82.5k|         return result;
  164|  82.5k|      }
  165|  82.5k|   }
_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|  82.5k|      {
   73|  82.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|  82.5k|         else {
   84|  82.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  82.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  82.5k|      }
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|  82.5k|      {
   44|  82.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  82.5k|      }
_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|  82.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  82.5k|      else {
  108|  82.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  82.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  82.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|  82.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|  82.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|  82.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|  82.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|  82.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|  82.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  82.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  82.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  82.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|  82.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  82.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  82.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|  82.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  82.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  82.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  82.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  82.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.7k, False: 68.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.7k|            else if constexpr( has_apply0_bool ) {
  153|  13.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.7k|            }
  155|  13.7k|         }
  156|  82.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.7k, False: 68.8k]
  ------------------
  157|  13.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.7k|         }
  159|  68.8k|         else {
  160|  68.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.8k|         }
  162|  82.5k|         (void)m( result );
  163|  82.5k|         return result;
  164|  82.5k|      }
  165|  82.5k|   }
_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|  82.5k|      {
   73|  82.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|  82.5k|         else {
   84|  82.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  82.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  82.5k|      }
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|  82.5k|      {
   44|  82.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  82.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  82.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  82.5k|      else {
  108|  82.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  82.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  82.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|  82.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|  82.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|  82.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|  82.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|  82.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|  82.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  82.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  82.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  82.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|  82.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  82.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  82.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|  82.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  82.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  82.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  82.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  82.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.7k, False: 68.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.7k|            else if constexpr( has_apply0_bool ) {
  153|  13.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.7k|            }
  155|  13.7k|         }
  156|  82.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.7k, False: 68.8k]
  ------------------
  157|  13.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.7k|         }
  159|  68.8k|         else {
  160|  68.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.8k|         }
  162|  82.5k|         (void)m( result );
  163|  82.5k|         return result;
  164|  82.5k|      }
  165|  82.5k|   }
_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|  82.5k|      {
   73|  82.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|  82.5k|         else {
   84|  82.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  82.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  82.5k|      }
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|  82.5k|      {
   59|  82.5k|         return Rule::match( in );
   60|  82.5k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDaRT4_DpOT5_:
  103|  13.7k|   {
  104|  13.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  13.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|  13.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  13.7k|      {
   44|  13.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.7k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEDaRT4_DpOT5_:
  103|  13.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.7k|      else {
  108|  13.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.7k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.7k|            else if constexpr( has_apply0_bool ) {
  153|  13.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.7k|            }
  155|  13.7k|         }
  156|  13.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.7k, False: 0]
  ------------------
  157|  13.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  13.7k|         (void)m( result );
  163|  13.7k|         return result;
  164|  13.7k|      }
  165|  13.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDaRT4_DpOT5_:
   72|  13.7k|      {
   73|  13.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|  13.7k|         else {
   84|  13.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  13.7k|      {
   44|  13.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.7k|      }
_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|   865k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   865k|      else {
  108|   865k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   865k|         using iterator_t = typename ParseInput::iterator_t;
  111|   865k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   865k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   865k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   865k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   865k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   865k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   865k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   865k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   865k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   865k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   865k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   865k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   865k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   865k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   865k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   865k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   865k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   865k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 851k, 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|   851k|            else if constexpr( has_apply0_bool ) {
  153|   851k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   851k|            }
  155|   851k|         }
  156|   865k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 851k, False: 13.7k]
  ------------------
  157|   851k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   851k|         }
  159|  13.7k|         else {
  160|  13.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.7k|         }
  162|   865k|         (void)m( result );
  163|   865k|         return result;
  164|   865k|      }
  165|   865k|   }
_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|   865k|      {
   73|   865k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   865k|         else {
   84|   865k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   865k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   865k|      }
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|   865k|      {
   44|   865k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   865k|      }
_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|   865k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   865k|      else {
  108|   865k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   865k|         using iterator_t = typename ParseInput::iterator_t;
  111|   865k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   865k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   865k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   865k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   865k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   865k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   865k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   865k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   865k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   865k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   865k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   865k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   865k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   865k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   865k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   865k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   865k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   865k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 851k, 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|   851k|            else if constexpr( has_apply0_bool ) {
  153|   851k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   851k|            }
  155|   851k|         }
  156|   865k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 851k, False: 13.7k]
  ------------------
  157|   851k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   851k|         }
  159|  13.7k|         else {
  160|  13.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.7k|         }
  162|   865k|         (void)m( result );
  163|   865k|         return result;
  164|   865k|      }
  165|   865k|   }
_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|   865k|      {
   73|   865k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   865k|         else {
   84|   865k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   865k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   865k|      }
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|   865k|      {
   44|   865k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   865k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   865k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   865k|      else {
  108|   865k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   865k|         using iterator_t = typename ParseInput::iterator_t;
  111|   865k|         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: 865k]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   865k|         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: 865k]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   865k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   865k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded, False: 865k]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   865k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded, False: 865k]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   865k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   865k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   865k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   865k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   865k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   865k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   865k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   865k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   865k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   865k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   865k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   865k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   865k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.7k, False: 851k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.7k|            else if constexpr( has_apply0_bool ) {
  153|  13.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.7k|            }
  155|  13.7k|         }
  156|   865k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.7k, False: 851k]
  ------------------
  157|  13.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.7k|         }
  159|   851k|         else {
  160|   851k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   851k|         }
  162|   865k|         (void)m( result );
  163|   865k|         return result;
  164|   865k|      }
  165|   865k|   }
_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|   865k|      {
   73|   865k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   865k|         else {
   84|   865k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   865k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   865k|      }
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|   865k|      {
   59|   865k|         return Rule::match( in );
   60|   865k|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   851k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   851k|      else {
  108|   851k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   851k|         using iterator_t = typename ParseInput::iterator_t;
  111|   851k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   851k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   851k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   851k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   851k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   851k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   851k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   851k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   851k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   851k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   851k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   851k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   851k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   851k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   851k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   851k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   851k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   851k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 851k, 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|   851k|            else if constexpr( has_apply0_bool ) {
  153|   851k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   851k|            }
  155|   851k|         }
  156|   851k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 851k, False: 0]
  ------------------
  157|   851k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   851k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   851k|         (void)m( result );
  163|   851k|         return result;
  164|   851k|      }
  165|   851k|   }
_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|   851k|      {
   73|   851k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   851k|         else {
   84|   851k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   851k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   851k|      }
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|   851k|      {
   59|   851k|         return Rule::match( in );
   60|   851k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.8k, False: 4.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|  38.8k|            else if constexpr( has_apply0_bool ) {
  153|  38.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.8k|            }
  155|  38.8k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.8k, False: 4.77k]
  ------------------
  157|  38.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.8k|         }
  159|  4.77k|         else {
  160|  4.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.77k|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   44|  43.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 43.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 43.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.5k, False: 106]
  ------------------
  143|  43.5k|            if constexpr( has_apply_void ) {
  144|  43.5k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  43.5k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.5k, False: 106]
  ------------------
  157|  43.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.5k|         }
  159|    106|         else {
  160|    106|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    106|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   44|  43.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.6k|      else {
  108|  43.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.7k, False: 3.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.7k|            else if constexpr( has_apply0_bool ) {
  153|  39.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.7k|            }
  155|  39.7k|         }
  156|  43.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.7k, False: 3.88k]
  ------------------
  157|  39.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.7k|         }
  159|  3.88k|         else {
  160|  3.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.88k|         }
  162|  43.6k|         (void)m( result );
  163|  43.6k|         return result;
  164|  43.6k|      }
  165|  43.6k|   }
_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|  43.6k|      {
   73|  43.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|  43.6k|         else {
   84|  43.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.6k|      }
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|  43.6k|      {
   59|  43.6k|         return Rule::match( in );
   60|  43.6k|      }
_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.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.88k|      else {
  108|  3.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.84k, False: 1.03k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.84k|            else if constexpr( has_apply0_bool ) {
  153|  2.84k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.84k|            }
  155|  2.84k|         }
  156|  3.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.84k, False: 1.03k]
  ------------------
  157|  2.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.84k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  3.88k|         (void)m( result );
  163|  3.88k|         return result;
  164|  3.88k|      }
  165|  3.88k|   }
_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.88k|      {
   73|  3.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.88k|         else {
   84|  3.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.88k|      {
   59|  3.88k|         return Rule::match( in );
   60|  3.88k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.03k|      else {
  108|  1.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14, False: 1.02k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     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.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14, False: 1.02k]
  ------------------
  157|     14|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     14|         }
  159|  1.02k|         else {
  160|  1.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.02k|         }
  162|  1.03k|         (void)m( result );
  163|  1.03k|         return result;
  164|  1.03k|      }
  165|  1.03k|   }
_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.03k|      {
   73|  1.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.03k|         else {
   84|  1.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.03k|      {
   59|  1.03k|         return Rule::match( in );
   60|  1.03k|      }
_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.02k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.02k|      else {
  108|  1.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.02k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.02k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.02k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.02k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.02k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.02k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.02k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.02k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 881, False: 144]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    881|            else if constexpr( has_apply0_bool ) {
  153|    881|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    881|            }
  155|    881|         }
  156|  1.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 881, False: 144]
  ------------------
  157|    881|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    881|         }
  159|    144|         else {
  160|    144|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    144|         }
  162|  1.02k|         (void)m( result );
  163|  1.02k|         return result;
  164|  1.02k|      }
  165|  1.02k|   }
_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.02k|      {
   73|  1.02k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.02k|         else {
   84|  1.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.02k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.02k|      {
   59|  1.02k|         return Rule::match( in );
   60|  1.02k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    144|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    144|      else {
  108|    144|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    144|         using iterator_t = typename ParseInput::iterator_t;
  111|    144|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    144|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    144|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    144|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    144|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    144|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    144|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    144|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    144|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    144|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    144|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    144|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    144|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    144|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    144|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    144|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    144|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    144|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38, False: 106]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     38|            else if constexpr( has_apply0_bool ) {
  153|     38|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     38|            }
  155|     38|         }
  156|    144|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38, False: 106]
  ------------------
  157|     38|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     38|         }
  159|    106|         else {
  160|    106|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    106|         }
  162|    144|         (void)m( result );
  163|    144|         return result;
  164|    144|      }
  165|    144|   }
_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|    144|      {
   73|    144|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    144|         else {
   84|    144|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    144|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    144|      }
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|    144|      {
   59|    144|         return Rule::match( in );
   60|    144|      }
_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|  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: 6]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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: 6]
  ------------------
  157|  43.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.5k|         }
  159|      6|         else {
  160|      6|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      6|         }
  162|  43.5k|         (void)m( result );
  163|  43.5k|         return result;
  164|  43.5k|      }
  165|  43.5k|   }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   120k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   120k|      else {
  108|   120k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   120k|         using iterator_t = typename ParseInput::iterator_t;
  111|   120k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   120k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   120k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   120k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   120k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   120k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   120k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   120k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   120k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   120k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   120k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   120k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   120k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   120k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   120k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   120k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   120k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   120k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 91.5k, False: 28.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|  91.5k|            else if constexpr( has_apply0_bool ) {
  153|  91.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  91.5k|            }
  155|  91.5k|         }
  156|   120k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 91.5k, False: 28.5k]
  ------------------
  157|  91.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  91.5k|         }
  159|  28.5k|         else {
  160|  28.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.5k|         }
  162|   120k|         (void)m( result );
  163|   120k|         return result;
  164|   120k|      }
  165|   120k|   }
_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|   120k|      {
   73|   120k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   120k|         else {
   84|   120k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   120k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   120k|      }
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|   120k|      {
   44|   120k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   120k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   120k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   120k|      else {
  108|   120k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   120k|         using iterator_t = typename ParseInput::iterator_t;
  111|   120k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   120k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   120k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   120k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   120k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   120k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   120k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   120k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   120k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   120k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   120k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   120k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   120k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   120k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   120k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   120k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   120k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   120k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 91.5k, False: 28.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|  91.5k|            else if constexpr( has_apply0_bool ) {
  153|  91.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  91.5k|            }
  155|  91.5k|         }
  156|   120k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 91.5k, False: 28.5k]
  ------------------
  157|  91.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  91.5k|         }
  159|  28.5k|         else {
  160|  28.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.5k|         }
  162|   120k|         (void)m( result );
  163|   120k|         return result;
  164|   120k|      }
  165|   120k|   }
_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|   120k|      {
   73|   120k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   120k|         else {
   84|   120k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   120k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   120k|      }
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|   120k|      {
   59|   120k|         return Rule::match( in );
   60|   120k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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): [True: 0, Folded]
  ------------------
  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): [True: 43.5k, Folded]
  |  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): [True: 43.5k, Folded]
  |  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: 2.78k, False: 40.7k]
  ------------------
  143|  2.78k|            if constexpr( has_apply_void ) {
  144|  2.78k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  2.78k|         }
  156|  43.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.77k, False: 40.7k]
  ------------------
  157|  2.77k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.77k|         }
  159|  40.7k|         else {
  160|  40.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.7k|         }
  162|  43.5k|         (void)m( result );
  163|  43.5k|         return result;
  164|  43.5k|      }
  165|  43.5k|   }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 2.81k, False: 40.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.81k|            else if constexpr( has_apply0_bool ) {
  153|  2.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.81k|            }
  155|  2.81k|         }
  156|  43.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.81k, False: 40.7k]
  ------------------
  157|  2.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.81k|         }
  159|  40.7k|         else {
  160|  40.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.7k|         }
  162|  43.5k|         (void)m( result );
  163|  43.5k|         return result;
  164|  43.5k|      }
  165|  43.5k|   }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.3k|      else {
  108|  46.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.13k, False: 43.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.13k|            else if constexpr( has_apply0_bool ) {
  153|  3.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.13k|            }
  155|  3.13k|         }
  156|  46.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.13k, False: 43.1k]
  ------------------
  157|  3.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.13k|         }
  159|  43.1k|         else {
  160|  43.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.1k|         }
  162|  46.3k|         (void)m( result );
  163|  46.3k|         return result;
  164|  46.3k|      }
  165|  46.3k|   }
_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|  46.3k|      {
   73|  46.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|  46.3k|         else {
   84|  46.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.3k|      }
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|  46.3k|      {
   44|  46.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  55.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  55.8k|      else {
  108|  55.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  55.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  55.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|  55.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|  55.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|  55.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|  55.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|  55.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|  55.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  55.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  55.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  55.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|  55.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  55.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  55.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|  55.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  55.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  55.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  55.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  55.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 12.6k, False: 43.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  12.6k|            else if constexpr( has_apply0_bool ) {
  153|  12.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  12.6k|            }
  155|  12.6k|         }
  156|  55.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 12.6k, False: 43.1k]
  ------------------
  157|  12.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  12.6k|         }
  159|  43.1k|         else {
  160|  43.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.1k|         }
  162|  55.8k|         (void)m( result );
  163|  55.8k|         return result;
  164|  55.8k|      }
  165|  55.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  55.8k|      {
   73|  55.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|  55.8k|         else {
   84|  55.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  55.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  55.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  55.8k|      {
   59|  55.8k|         return Rule::match( in );
   60|  55.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  43.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.1k|      else {
  108|  43.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.45k, False: 40.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.45k|            else if constexpr( has_apply0_bool ) {
  153|  2.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.45k|            }
  155|  2.45k|         }
  156|  43.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.45k, False: 40.7k]
  ------------------
  157|  2.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.45k|         }
  159|  40.7k|         else {
  160|  40.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.7k|         }
  162|  43.1k|         (void)m( result );
  163|  43.1k|         return result;
  164|  43.1k|      }
  165|  43.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  43.1k|      {
   73|  43.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|  43.1k|         else {
   84|  43.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  43.1k|      {
   59|  43.1k|         return Rule::match( in );
   60|  43.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.81k|      else {
  108|  2.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.81k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.79k, False: 25]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.79k|            else if constexpr( has_apply0_bool ) {
  153|  2.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.79k|            }
  155|  2.79k|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.79k, False: 25]
  ------------------
  157|  2.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.79k|         }
  159|     25|         else {
  160|     25|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     25|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_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.81k|      {
   73|  2.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.81k|         else {
   84|  2.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.81k|      {
   59|  2.81k|         return Rule::match( in );
   60|  2.81k|      }
_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.79k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.79k|      else {
  108|  2.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.79k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.79k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.79k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.79k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.79k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.79k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.79k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.79k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.78k, 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.78k|            else if constexpr( has_apply0_bool ) {
  153|  2.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.78k|            }
  155|  2.78k|         }
  156|  2.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.78k, False: 10]
  ------------------
  157|  2.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.78k|         }
  159|     10|         else {
  160|     10|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     10|         }
  162|  2.79k|         (void)m( result );
  163|  2.79k|         return result;
  164|  2.79k|      }
  165|  2.79k|   }
_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.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_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.79k|      {
   44|  2.79k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.79k|      }
_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|  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: 38.8k, False: 4.66k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.8k|            else if constexpr( has_apply0_bool ) {
  153|  38.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.8k|            }
  155|  38.8k|         }
  156|  43.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.8k, False: 4.66k]
  ------------------
  157|  38.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.8k|         }
  159|  4.66k|         else {
  160|  4.66k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.66k|         }
  162|  43.5k|         (void)m( result );
  163|  43.5k|         return result;
  164|  43.5k|      }
  165|  43.5k|   }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_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|  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_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|  43.5k|      {
   44|  43.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.5k|      }
_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|  41.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.9k|      else {
  108|  41.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  41.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  41.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  41.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  41.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  41.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  41.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  41.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.5k, False: 12.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.5k|            else if constexpr( has_apply0_bool ) {
  153|  29.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.5k|            }
  155|  29.5k|         }
  156|  41.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.5k, False: 12.4k]
  ------------------
  157|  29.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.5k|         }
  159|  12.4k|         else {
  160|  12.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.4k|         }
  162|  41.9k|         (void)m( result );
  163|  41.9k|         return result;
  164|  41.9k|      }
  165|  41.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|  41.9k|      {
   73|  41.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  41.9k|         else {
   84|  41.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  41.9k|      {
   44|  41.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.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|  48.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.0k|      else {
  108|  48.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.9k, False: 15.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|  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|  48.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.9k, False: 15.0k]
  ------------------
  157|  32.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.9k|         }
  159|  15.0k|         else {
  160|  15.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.0k|         }
  162|  48.0k|         (void)m( result );
  163|  48.0k|         return result;
  164|  48.0k|      }
  165|  48.0k|   }
_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|  48.0k|      {
   73|  48.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.0k|         else {
   84|  48.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  48.0k|      {
   44|  48.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.0k|      else {
  108|  48.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.34k, False: 44.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  48.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 44.6k]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|  44.6k|         else {
  160|  44.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.6k|         }
  162|  48.0k|         (void)m( result );
  163|  48.0k|         return result;
  164|  48.0k|      }
  165|  48.0k|   }
_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|  48.0k|      {
   73|  48.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.0k|         else {
   84|  48.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  48.0k|      {
   44|  48.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.0k|      }
_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|  48.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.0k|      else {
  108|  48.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.34k, False: 44.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  48.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 44.6k]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|  44.6k|         else {
  160|  44.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.6k|         }
  162|  48.0k|         (void)m( result );
  163|  48.0k|         return result;
  164|  48.0k|      }
  165|  48.0k|   }
_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|  48.0k|      {
   73|  48.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.0k|         else {
   84|  48.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  48.0k|      {
   44|  48.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.0k|      else {
  108|  48.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  48.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 48.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 48.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.83k, False: 44.1k]
  ------------------
  143|  3.83k|            if constexpr( has_apply_void ) {
  144|  3.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.83k|         }
  156|  48.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.83k, False: 44.1k]
  ------------------
  157|  3.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.83k|         }
  159|  44.1k|         else {
  160|  44.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.1k|         }
  162|  48.0k|         (void)m( result );
  163|  48.0k|         return result;
  164|  48.0k|      }
  165|  48.0k|   }
_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|  48.0k|      {
   73|  48.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.0k|         else {
   84|  48.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  48.0k|      {
   59|  48.0k|         return Rule::match( in );
   60|  48.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   809k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   809k|      else {
  108|   809k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   809k|         using iterator_t = typename ParseInput::iterator_t;
  111|   809k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   809k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   809k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   809k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   809k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   809k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   809k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   809k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   809k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   809k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   809k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   809k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   809k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   809k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   809k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   809k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   809k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   809k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 807k, 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|   807k|            else if constexpr( has_apply0_bool ) {
  153|   807k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   807k|            }
  155|   807k|         }
  156|   809k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 807k, False: 1.24k]
  ------------------
  157|   807k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   807k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|   809k|         (void)m( result );
  163|   809k|         return result;
  164|   809k|      }
  165|   809k|   }
_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|   809k|      {
   73|   809k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   809k|         else {
   84|   809k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   809k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   809k|      }
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|   809k|      {
   44|   809k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   809k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   809k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   809k|      else {
  108|   809k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   809k|         using iterator_t = typename ParseInput::iterator_t;
  111|   809k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   809k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   809k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   809k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   809k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   809k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   809k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   809k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   809k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   809k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   809k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   809k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   809k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   809k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   809k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   809k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   809k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   809k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 807k, 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|   807k|            else if constexpr( has_apply0_bool ) {
  153|   807k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   807k|            }
  155|   807k|         }
  156|   809k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 807k, False: 1.24k]
  ------------------
  157|   807k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   807k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|   809k|         (void)m( result );
  163|   809k|         return result;
  164|   809k|      }
  165|   809k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   809k|      {
   73|   809k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   809k|         else {
   84|   809k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   809k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   809k|      }
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|   809k|      {
   59|   809k|         return Rule::match( in );
   60|   809k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   822k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   822k|      else {
  108|   822k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   822k|         using iterator_t = typename ParseInput::iterator_t;
  111|   822k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   822k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   822k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   822k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   822k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   822k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   822k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   822k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   822k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   822k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   822k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   822k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   822k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   822k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   822k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   822k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   822k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   822k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.2k, False: 812k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  10.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.2k|            }
  155|  10.2k|         }
  156|   822k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.2k, False: 812k]
  ------------------
  157|  10.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.2k|         }
  159|   812k|         else {
  160|   812k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   812k|         }
  162|   822k|         (void)m( result );
  163|   822k|         return result;
  164|   822k|      }
  165|   822k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   822k|      {
   73|   822k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   822k|         else {
   84|   822k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   822k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   822k|      }
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|   822k|      {
   59|   822k|         return Rule::match( in );
   60|   822k|      }
_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.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: 3.34k, False: 470]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.34k|            else if constexpr( has_apply0_bool ) {
  153|  3.34k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.34k|            }
  155|  3.34k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.34k, False: 470]
  ------------------
  157|  3.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.34k|         }
  159|    470|         else {
  160|    470|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    470|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.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_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.81k|      {
   44|  3.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.81k|      }
_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.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.09k, 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|  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|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.09k, False: 1.71k]
  ------------------
  157|  2.09k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.09k|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.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_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.81k|      {
   44|  3.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.81k|      }
_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.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: 3.81k, 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.81k|            else if constexpr( has_apply0_bool ) {
  153|  3.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.81k|            }
  155|  3.81k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.81k, False: 0]
  ------------------
  157|  3.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.81k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.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_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.81k|      {
   44|  3.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.81k|      }
_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.81k|   {
  104|  3.81k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.81k|   }
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.81k|      {
   44|  3.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_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): [True: 0, Folded]
  ------------------
  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): [True: 3.81k, Folded]
  |  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): [True: 3.81k, Folded]
  |  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: 1.73k, False: 2.08k]
  ------------------
  143|  1.73k|            if constexpr( has_apply_void ) {
  144|  1.73k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.73k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.73k, False: 2.08k]
  ------------------
  157|  1.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.73k|         }
  159|  2.08k|         else {
  160|  2.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.08k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.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_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.81k|      {
   44|  3.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.81k|      }
_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.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: 228, False: 3.58k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    228|            else if constexpr( has_apply0_bool ) {
  153|    228|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    228|            }
  155|    228|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 228, False: 3.58k]
  ------------------
  157|    228|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    228|         }
  159|  3.58k|         else {
  160|  3.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.58k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.81k|      {
   73|  3.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.81k|         else {
   84|  3.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.81k|      {
   59|  3.81k|         return Rule::match( in );
   60|  3.81k|      }
_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.58k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.58k|      else {
  108|  3.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 210, False: 3.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|    210|            else if constexpr( has_apply0_bool ) {
  153|    210|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    210|            }
  155|    210|         }
  156|  3.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 210, False: 3.37k]
  ------------------
  157|    210|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    210|         }
  159|  3.37k|         else {
  160|  3.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.37k|         }
  162|  3.58k|         (void)m( result );
  163|  3.58k|         return result;
  164|  3.58k|      }
  165|  3.58k|   }
_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.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.58k|         else {
   84|  3.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.58k|      {
   59|  3.58k|         return Rule::match( in );
   60|  3.58k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.37k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.37k|      else {
  108|  3.37k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.37k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.37k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.37k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.37k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.37k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.37k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.37k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.37k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.37k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.37k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.37k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.37k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.37k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.37k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.37k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 3.17k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  3.37k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.17k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.17k|         else {
  160|  3.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.17k|         }
  162|  3.37k|         (void)m( result );
  163|  3.37k|         return result;
  164|  3.37k|      }
  165|  3.37k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.37k|      {
   73|  3.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|  3.37k|         else {
   84|  3.37k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.37k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.37k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.37k|      {
   59|  3.37k|         return Rule::match( in );
   60|  3.37k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.17k|      else {
  108|  3.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 359, 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|    359|            else if constexpr( has_apply0_bool ) {
  153|    359|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    359|            }
  155|    359|         }
  156|  3.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 359, False: 2.82k]
  ------------------
  157|    359|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    359|         }
  159|  2.82k|         else {
  160|  2.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.82k|         }
  162|  3.17k|         (void)m( result );
  163|  3.17k|         return result;
  164|  3.17k|      }
  165|  3.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.17k|      {
   73|  3.17k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.17k|         else {
   84|  3.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.17k|      {
   59|  3.17k|         return Rule::match( in );
   60|  3.17k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_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: 543, False: 2.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    543|            else if constexpr( has_apply0_bool ) {
  153|    543|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    543|            }
  155|    543|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 543, False: 2.27k]
  ------------------
  157|    543|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    543|         }
  159|  2.27k|         else {
  160|  2.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.27k|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_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.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.82k|      {
   59|  2.82k|         return Rule::match( in );
   60|  2.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.27k|      else {
  108|  2.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 2.08k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 2.08k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  2.08k|         else {
  160|  2.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.08k|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.27k|         else {
   84|  2.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.27k|      {
   59|  2.27k|         return Rule::match( in );
   60|  2.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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.33k, False: 1.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.33k|            else if constexpr( has_apply0_bool ) {
  153|  2.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.33k|            }
  155|  2.33k|         }
  156|  3.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.33k, False: 1.47k]
  ------------------
  157|  2.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.33k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  3.81k|         (void)m( result );
  163|  3.81k|         return result;
  164|  3.81k|      }
  165|  3.81k|   }
_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.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_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.81k|      {
   59|  3.81k|         return Rule::match( in );
   60|  3.81k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.61k|      else {
  108|  4.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.61k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.61k, 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.61k|            else if constexpr( has_apply0_bool ) {
  153|  4.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.61k|            }
  155|  4.61k|         }
  156|  4.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.61k, False: 0]
  ------------------
  157|  4.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.61k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.61k|         (void)m( result );
  163|  4.61k|         return result;
  164|  4.61k|      }
  165|  4.61k|   }
_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.61k|      {
   73|  4.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.61k|         else {
   84|  4.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.61k|      }
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.61k|      {
   44|  4.61k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.61k|      }
_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.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.33k|      else {
  108|  2.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.27k, False: 62]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.27k|            else if constexpr( has_apply0_bool ) {
  153|  2.27k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.27k|            }
  155|  2.27k|         }
  156|  2.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.27k, False: 62]
  ------------------
  157|  2.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.27k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|  2.33k|         (void)m( result );
  163|  2.33k|         return result;
  164|  2.33k|      }
  165|  2.33k|   }
_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.33k|      {
   73|  2.33k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.33k|         else {
   84|  2.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.33k|      {
   44|  2.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.33k|      }
_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.27k|   {
  104|  2.27k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.27k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.27k|   }
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.27k|      {
   44|  2.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.27k|      }
_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|   803k|   {
  104|   803k|      if constexpr( !Control< Rule >::enable ) {
  105|   803k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   803k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_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|   803k|      {
   44|   803k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   803k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.27k|      else {
  108|  2.27k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.27k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.27k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.27k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.27k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.27k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.27k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.27k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.27k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.27k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.27k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.27k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.27k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.27k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.27k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.09k, False: 177]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.09k, False: 177]
  ------------------
  157|  2.09k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.09k|         }
  159|    177|         else {
  160|    177|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    177|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_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.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.27k|         else {
   84|  2.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.27k|      {
   59|  2.27k|         return Rule::match( in );
   60|  2.27k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   806k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   806k|      else {
  108|   806k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   806k|         using iterator_t = typename ParseInput::iterator_t;
  111|   806k|         constexpr bool has_apply_void = 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|   806k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   806k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 806k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   806k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   806k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   806k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   806k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   806k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   806k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   806k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   806k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   806k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   806k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   806k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 806k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   806k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   806k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   806k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   806k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 804k, False: 1.61k]
  ------------------
  143|   804k|            if constexpr( has_apply_void ) {
  144|   804k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   804k|         }
  156|   806k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 804k, False: 1.61k]
  ------------------
  157|   804k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   804k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|   806k|         (void)m( result );
  163|   806k|         return result;
  164|   806k|      }
  165|   806k|   }
_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|   806k|      {
   73|   806k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   806k|         else {
   84|   806k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   806k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   806k|      }
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|   806k|      {
   44|   806k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   806k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   806k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   806k|      else {
  108|   806k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   806k|         using iterator_t = typename ParseInput::iterator_t;
  111|   806k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   806k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   806k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   806k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   806k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   806k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   806k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   806k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   806k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   806k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   806k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   806k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   806k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   806k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   806k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   806k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   806k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   806k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 804k, 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|   804k|            else if constexpr( has_apply0_bool ) {
  153|   804k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   804k|            }
  155|   804k|         }
  156|   806k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 804k, False: 1.54k]
  ------------------
  157|   804k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   804k|         }
  159|  1.54k|         else {
  160|  1.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.54k|         }
  162|   806k|         (void)m( result );
  163|   806k|         return result;
  164|   806k|      }
  165|   806k|   }
_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|   806k|      {
   73|   806k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   806k|         else {
   84|   806k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   806k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   806k|      }
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|   806k|      {
   44|   806k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   806k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.61M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.61M|      else {
  108|  1.61M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.61M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.61M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.61M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.61M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.61M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.61M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.61M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.61M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.61M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.61M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.61M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.61M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.61M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.61M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.61M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.61M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.61M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.61M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.61M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.59k, False: 1.60M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.59k|            else if constexpr( has_apply0_bool ) {
  153|  1.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.59k|            }
  155|  1.59k|         }
  156|  1.61M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.59k, False: 1.60M]
  ------------------
  157|  1.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.59k|         }
  159|  1.60M|         else {
  160|  1.60M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60M|         }
  162|  1.61M|         (void)m( result );
  163|  1.61M|         return result;
  164|  1.61M|      }
  165|  1.61M|   }
_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.61M|      {
   73|  1.61M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.61M|         else {
   84|  1.61M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.61M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.61M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.61M|      {
   44|  1.61M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.61M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.61M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.61M|      else {
  108|  1.61M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.61M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.61M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.61M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.61M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.61M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.61M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.61M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.61M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.61M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.61M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.61M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.61M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.61M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.61M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.61M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.61M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.61M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.61M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.61M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.52k, False: 1.60M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.52k|            else if constexpr( has_apply0_bool ) {
  153|  6.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.52k|            }
  155|  6.52k|         }
  156|  1.61M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.52k, False: 1.60M]
  ------------------
  157|  6.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.52k|         }
  159|  1.60M|         else {
  160|  1.60M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60M|         }
  162|  1.61M|         (void)m( result );
  163|  1.61M|         return result;
  164|  1.61M|      }
  165|  1.61M|   }
_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.61M|      {
   73|  1.61M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.61M|         else {
   84|  1.61M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.61M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.61M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.61M|      {
   59|  1.61M|         return Rule::match( in );
   60|  1.61M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.60M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.60M|      else {
  108|  1.60M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.60M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.60M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.60M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.60M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.60M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.60M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.60M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.60M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.60M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.60M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.60M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.60M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.60M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.60M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.60M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.60M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.60M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.60M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.60M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.60M, False: 1.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|  1.60M|            else if constexpr( has_apply0_bool ) {
  153|  1.60M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.60M|            }
  155|  1.60M|         }
  156|  1.60M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.60M, False: 1.57k]
  ------------------
  157|  1.60M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.60M|         }
  159|  1.57k|         else {
  160|  1.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.57k|         }
  162|  1.60M|         (void)m( result );
  163|  1.60M|         return result;
  164|  1.60M|      }
  165|  1.60M|   }
_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.60M|      {
   73|  1.60M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.60M|         else {
   84|  1.60M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.60M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.60M|      }
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.60M|      {
   59|  1.60M|         return Rule::match( in );
   60|  1.60M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   804k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   804k|      else {
  108|   804k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   804k|         using iterator_t = typename ParseInput::iterator_t;
  111|   804k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   804k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   804k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   804k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   804k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   804k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   804k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   804k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   804k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   804k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   804k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   804k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   804k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   804k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   804k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   804k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   804k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   804k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 804k, False: 42]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   804k|            else if constexpr( has_apply0_bool ) {
  153|   804k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   804k|            }
  155|   804k|         }
  156|   804k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 804k, False: 42]
  ------------------
  157|   804k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   804k|         }
  159|     42|         else {
  160|     42|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     42|         }
  162|   804k|         (void)m( result );
  163|   804k|         return result;
  164|   804k|      }
  165|   804k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   804k|      {
   73|   804k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   804k|         else {
   84|   804k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   804k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   804k|      }
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|   804k|      {
   59|   804k|         return Rule::match( in );
   60|   804k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   804k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   804k|      else {
  108|   804k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   804k|         using iterator_t = typename ParseInput::iterator_t;
  111|   804k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   804k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   804k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   804k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   804k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   804k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   804k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   804k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   804k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   804k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   804k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   804k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   804k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   804k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   804k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   804k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   804k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   804k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 804k, False: 22]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   804k|            else if constexpr( has_apply0_bool ) {
  153|   804k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   804k|            }
  155|   804k|         }
  156|   804k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 804k, False: 22]
  ------------------
  157|   804k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   804k|         }
  159|     22|         else {
  160|     22|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     22|         }
  162|   804k|         (void)m( result );
  163|   804k|         return result;
  164|   804k|      }
  165|   804k|   }
_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|   804k|      {
   73|   804k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   804k|         else {
   84|   804k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   804k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   804k|      }
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|   804k|      {
   44|   804k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   804k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.6k|      else {
  108|  44.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.52k, False: 41.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.52k|            else if constexpr( has_apply0_bool ) {
  153|  3.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.52k|            }
  155|  3.52k|         }
  156|  44.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.52k, False: 41.1k]
  ------------------
  157|  3.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.52k|         }
  159|  41.1k|         else {
  160|  41.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.1k|         }
  162|  44.6k|         (void)m( result );
  163|  44.6k|         return result;
  164|  44.6k|      }
  165|  44.6k|   }
_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|  44.6k|      {
   73|  44.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|  44.6k|         else {
   84|  44.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.6k|      }
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|  44.6k|      {
   44|  44.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.6k|      }
_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|  44.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.6k|      else {
  108|  44.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.52k, False: 41.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.52k|            else if constexpr( has_apply0_bool ) {
  153|  3.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.52k|            }
  155|  3.52k|         }
  156|  44.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.52k, False: 41.1k]
  ------------------
  157|  3.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.52k|         }
  159|  41.1k|         else {
  160|  41.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  41.1k|         }
  162|  44.6k|         (void)m( result );
  163|  44.6k|         return result;
  164|  44.6k|      }
  165|  44.6k|   }
_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|  44.6k|      {
   73|  44.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|  44.6k|         else {
   84|  44.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.6k|      }
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|  44.6k|      {
   44|  44.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.6k|      else {
  108|  44.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 44.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.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|  44.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|  44.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|  44.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 44.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.26k, False: 40.4k]
  ------------------
  143|  4.26k|            if constexpr( has_apply_void ) {
  144|  4.26k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.26k|         }
  156|  44.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.25k, False: 40.4k]
  ------------------
  157|  4.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.25k|         }
  159|  40.4k|         else {
  160|  40.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.4k|         }
  162|  44.6k|         (void)m( result );
  163|  44.6k|         return result;
  164|  44.6k|      }
  165|  44.6k|   }
_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|  44.6k|      {
   73|  44.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|  44.6k|         else {
   84|  44.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.6k|      }
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|  44.6k|      {
   59|  44.6k|         return Rule::match( in );
   60|  44.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   463k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   463k|      else {
  108|   463k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   463k|         using iterator_t = typename ParseInput::iterator_t;
  111|   463k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   463k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   463k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   463k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   463k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   463k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   463k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   463k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   463k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   463k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   463k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   463k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   463k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   463k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   463k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   463k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   463k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   463k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 461k, False: 2.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   461k|            else if constexpr( has_apply0_bool ) {
  153|   461k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   461k|            }
  155|   461k|         }
  156|   463k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 461k, False: 2.41k]
  ------------------
  157|   461k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   461k|         }
  159|  2.41k|         else {
  160|  2.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.41k|         }
  162|   463k|         (void)m( result );
  163|   463k|         return result;
  164|   463k|      }
  165|   463k|   }
_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|   463k|      {
   73|   463k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   463k|         else {
   84|   463k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   463k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   463k|      }
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|   463k|      {
   44|   463k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   463k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   463k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   463k|      else {
  108|   463k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   463k|         using iterator_t = typename ParseInput::iterator_t;
  111|   463k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   463k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   463k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   463k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   463k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   463k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   463k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   463k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   463k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   463k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   463k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   463k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   463k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   463k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   463k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   463k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   463k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   463k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 461k, False: 2.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   461k|            else if constexpr( has_apply0_bool ) {
  153|   461k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   461k|            }
  155|   461k|         }
  156|   463k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 461k, False: 2.41k]
  ------------------
  157|   461k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   461k|         }
  159|  2.41k|         else {
  160|  2.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.41k|         }
  162|   463k|         (void)m( result );
  163|   463k|         return result;
  164|   463k|      }
  165|   463k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   463k|      {
   73|   463k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   463k|         else {
   84|   463k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   463k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   463k|      }
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|   463k|      {
   59|   463k|         return Rule::match( in );
   60|   463k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   473k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   473k|      else {
  108|   473k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   473k|         using iterator_t = typename ParseInput::iterator_t;
  111|   473k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   473k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   473k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   473k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   473k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   473k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   473k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   473k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   473k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   473k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   473k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   473k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   473k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   473k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   473k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   473k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   473k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   473k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.83k, False: 467k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.83k|            else if constexpr( has_apply0_bool ) {
  153|  5.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.83k|            }
  155|  5.83k|         }
  156|   473k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.83k, False: 467k]
  ------------------
  157|  5.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.83k|         }
  159|   467k|         else {
  160|   467k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   467k|         }
  162|   473k|         (void)m( result );
  163|   473k|         return result;
  164|   473k|      }
  165|   473k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   473k|      {
   73|   473k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   473k|         else {
   84|   473k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   473k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   473k|      }
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|   473k|      {
   59|   473k|         return Rule::match( in );
   60|   473k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.52k, False: 721]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.52k|            else if constexpr( has_apply0_bool ) {
  153|  3.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.52k|            }
  155|  3.52k|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.52k, False: 721]
  ------------------
  157|  3.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.52k|         }
  159|    721|         else {
  160|    721|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    721|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.24k|      {
   44|  4.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 1.33k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 1.33k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  1.33k|         else {
  160|  1.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.33k|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.24k|      {
   44|  4.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.24k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.24k, 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  4.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.24k|            }
  155|  4.24k|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.24k, False: 0]
  ------------------
  157|  4.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.24k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.24k|      {
   44|  4.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.24k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|  4.24k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.24k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.24k|      {
   44|  4.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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): [True: 0, Folded]
  ------------------
  112|  4.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|  4.24k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.24k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.24k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 2.31k]
  ------------------
  143|  1.92k|            if constexpr( has_apply_void ) {
  144|  1.92k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.92k|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 2.31k]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|  2.31k|         else {
  160|  2.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.31k|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.24k|      {
   44|  4.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.24k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 383, 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|    383|            else if constexpr( has_apply0_bool ) {
  153|    383|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    383|            }
  155|    383|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 383, False: 3.85k]
  ------------------
  157|    383|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    383|         }
  159|  3.85k|         else {
  160|  3.85k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.85k|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.24k|      {
   59|  4.24k|         return Rule::match( in );
   60|  4.24k|      }
_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.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: 305, False: 3.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    305|            else if constexpr( has_apply0_bool ) {
  153|    305|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    305|            }
  155|    305|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 305, False: 3.55k]
  ------------------
  157|    305|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    305|         }
  159|  3.55k|         else {
  160|  3.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.55k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_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.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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.85k|      {
   59|  3.85k|         return Rule::match( in );
   60|  3.85k|      }
_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.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 496, False: 3.05k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    496|            else if constexpr( has_apply0_bool ) {
  153|    496|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    496|            }
  155|    496|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 496, False: 3.05k]
  ------------------
  157|    496|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    496|         }
  159|  3.05k|         else {
  160|  3.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.05k|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_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.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
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.55k|      {
   59|  3.55k|         return Rule::match( in );
   60|  3.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.05k|      else {
  108|  3.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  3.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.86k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.86k|         else {
  160|  2.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.86k|         }
  162|  3.05k|         (void)m( result );
  163|  3.05k|         return result;
  164|  3.05k|      }
  165|  3.05k|   }
_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|  3.05k|      {
   73|  3.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|  3.05k|         else {
   84|  3.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.05k|      }
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|  3.05k|      {
   59|  3.05k|         return Rule::match( in );
   60|  3.05k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.86k|      else {
  108|  2.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.86k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 356, False: 2.50k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    356|            else if constexpr( has_apply0_bool ) {
  153|    356|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    356|            }
  155|    356|         }
  156|  2.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 356, False: 2.50k]
  ------------------
  157|    356|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    356|         }
  159|  2.50k|         else {
  160|  2.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.50k|         }
  162|  2.86k|         (void)m( result );
  163|  2.86k|         return result;
  164|  2.86k|      }
  165|  2.86k|   }
_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.86k|      {
   73|  2.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.86k|         else {
   84|  2.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.86k|      {
   59|  2.86k|         return Rule::match( in );
   60|  2.86k|      }
_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.50k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50k|      else {
  108|  2.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, False: 2.31k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.31k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.31k|         else {
  160|  2.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.31k|         }
  162|  2.50k|         (void)m( result );
  163|  2.50k|         return result;
  164|  2.50k|      }
  165|  2.50k|   }
_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.50k|      {
   73|  2.50k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50k|         else {
   84|  2.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.50k|      {
   59|  2.50k|         return Rule::match( in );
   60|  2.50k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.24k|      else {
  108|  4.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.10k, False: 1.13k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.10k|            else if constexpr( has_apply0_bool ) {
  153|  3.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.10k|            }
  155|  3.10k|         }
  156|  4.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.10k, False: 1.13k]
  ------------------
  157|  3.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.10k|         }
  159|  1.13k|         else {
  160|  1.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.13k|         }
  162|  4.24k|         (void)m( result );
  163|  4.24k|         return result;
  164|  4.24k|      }
  165|  4.24k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.24k|      {
   73|  4.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|  4.24k|         else {
   84|  4.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.24k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.24k|      {
   59|  4.24k|         return Rule::match( in );
   60|  4.24k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.14k|      else {
  108|  6.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.14k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.14k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.14k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.14k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.14k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.14k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.14k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.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|  6.14k|            else if constexpr( has_apply0_bool ) {
  153|  6.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.14k|            }
  155|  6.14k|         }
  156|  6.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.14k, False: 0]
  ------------------
  157|  6.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.14k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.14k|         (void)m( result );
  163|  6.14k|         return result;
  164|  6.14k|      }
  165|  6.14k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  6.14k|      {
   73|  6.14k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.14k|         else {
   84|  6.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.14k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.14k|      {
   44|  6.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.14k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.10k|      else {
  108|  3.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.03k, False: 70]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.03k|            else if constexpr( has_apply0_bool ) {
  153|  3.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.03k|            }
  155|  3.03k|         }
  156|  3.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.03k, False: 70]
  ------------------
  157|  3.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.03k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  3.10k|         (void)m( result );
  163|  3.10k|         return result;
  164|  3.10k|      }
  165|  3.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.10k|      {
   73|  3.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|  3.10k|         else {
   84|  3.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.10k|      {
   44|  3.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.10k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.05k|   {
  104|  3.05k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.05k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.05k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.05k|      {
   44|  3.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.05k|      }
_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|   457k|   {
  104|   457k|      if constexpr( !Control< Rule >::enable ) {
  105|   457k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   457k|   }
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|   457k|      {
   44|   457k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   457k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 133]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 133]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|    133|         else {
  160|    133|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    133|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   459k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   459k|      else {
  108|   459k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   459k|         using iterator_t = typename ParseInput::iterator_t;
  111|   459k|         constexpr bool has_apply_void = 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|   459k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   459k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 459k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   459k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   459k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   459k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   459k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   459k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   459k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   459k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   459k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   459k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   459k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   459k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 459k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   459k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   459k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   459k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   459k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 458k, False: 1.34k]
  ------------------
  143|   458k|            if constexpr( has_apply_void ) {
  144|   458k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   458k|         }
  156|   459k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 458k, False: 1.44k]
  ------------------
  157|   458k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   458k|         }
  159|  1.44k|         else {
  160|  1.44k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.44k|         }
  162|   459k|         (void)m( result );
  163|   459k|         return result;
  164|   459k|      }
  165|   459k|   }
_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|   459k|      {
   73|   459k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   459k|         else {
   84|   459k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   459k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   459k|      }
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|   459k|      {
   44|   459k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   459k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   459k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   459k|      else {
  108|   459k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   459k|         using iterator_t = typename ParseInput::iterator_t;
  111|   459k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   459k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   459k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   459k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   459k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   459k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   459k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   459k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   459k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   459k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   459k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   459k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   459k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   459k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   459k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   459k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   459k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   459k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 458k, False: 1.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|   458k|            else if constexpr( has_apply0_bool ) {
  153|   458k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   458k|            }
  155|   458k|         }
  156|   459k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 458k, False: 1.05k]
  ------------------
  157|   458k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   458k|         }
  159|  1.05k|         else {
  160|  1.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.05k|         }
  162|   459k|         (void)m( result );
  163|   459k|         return result;
  164|   459k|      }
  165|   459k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   459k|      {
   73|   459k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   459k|         else {
   84|   459k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   459k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   459k|      }
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|   459k|      {
   59|   459k|         return Rule::match( in );
   60|   459k|      }
_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|   458k|   {
  104|   458k|      if constexpr( !Control< Rule >::enable ) {
  105|   458k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   458k|   }
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|   458k|      {
   44|   458k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   458k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   458k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   458k|      else {
  108|   458k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   458k|         using iterator_t = typename ParseInput::iterator_t;
  111|   458k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   458k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   458k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   458k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   458k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   458k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   458k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   458k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   458k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   458k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   458k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   458k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   458k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   458k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   458k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   458k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   458k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   458k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 458k, 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|   458k|            else if constexpr( has_apply0_bool ) {
  153|   458k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   458k|            }
  155|   458k|         }
  156|   458k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 458k, False: 297]
  ------------------
  157|   458k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   458k|         }
  159|    297|         else {
  160|    297|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    297|         }
  162|   458k|         (void)m( result );
  163|   458k|         return result;
  164|   458k|      }
  165|   458k|   }
_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|   458k|      {
   73|   458k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   458k|         else {
   84|   458k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   458k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   458k|      }
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|   458k|      {
   44|   458k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   458k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  16.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.7M|      else {
  108|  16.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.7M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  16.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 458k, False: 16.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|   458k|            else if constexpr( has_apply0_bool ) {
  153|   458k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   458k|            }
  155|   458k|         }
  156|  16.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 458k, False: 16.3M]
  ------------------
  157|   458k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   458k|         }
  159|  16.3M|         else {
  160|  16.3M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.3M|         }
  162|  16.7M|         (void)m( result );
  163|  16.7M|         return result;
  164|  16.7M|      }
  165|  16.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  16.7M|      {
   73|  16.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.7M|         else {
   84|  16.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.7M|      {
   59|  16.7M|         return Rule::match( in );
   60|  16.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.3M|      else {
  108|  16.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.3M, 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|  16.3M|            else if constexpr( has_apply0_bool ) {
  153|  16.3M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.3M|            }
  155|  16.3M|         }
  156|  16.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.3M, False: 297]
  ------------------
  157|  16.3M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.3M|         }
  159|    297|         else {
  160|    297|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    297|         }
  162|  16.3M|         (void)m( result );
  163|  16.3M|         return result;
  164|  16.3M|      }
  165|  16.3M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.3M|      {
   73|  16.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|  16.3M|         else {
   84|  16.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.3M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.3M|      {
   44|  16.3M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.3M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.3M|      else {
  108|  16.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 244k, False: 16.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|   244k|            else if constexpr( has_apply0_bool ) {
  153|   244k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   244k|            }
  155|   244k|         }
  156|  16.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 244k, False: 16.0M]
  ------------------
  157|   244k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   244k|         }
  159|  16.0M|         else {
  160|  16.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.0M|         }
  162|  16.3M|         (void)m( result );
  163|  16.3M|         return result;
  164|  16.3M|      }
  165|  16.3M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.3M|      {
   73|  16.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|  16.3M|         else {
   84|  16.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.3M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.3M|      {
   44|  16.3M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.3M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  16.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.3M|      else {
  108|  16.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 244k, False: 16.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|   244k|            else if constexpr( has_apply0_bool ) {
  153|   244k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   244k|            }
  155|   244k|         }
  156|  16.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 244k, False: 16.0M]
  ------------------
  157|   244k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   244k|         }
  159|  16.0M|         else {
  160|  16.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.0M|         }
  162|  16.3M|         (void)m( result );
  163|  16.3M|         return result;
  164|  16.3M|      }
  165|  16.3M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  16.3M|      {
   73|  16.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|  16.3M|         else {
   84|  16.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.3M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.3M|      {
   59|  16.3M|         return Rule::match( in );
   60|  16.3M|      }
_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|   244k|   {
  104|   244k|      if constexpr( !Control< Rule >::enable ) {
  105|   244k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   244k|   }
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|   244k|      {
   44|   244k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   244k|      }
_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|   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: 244k, False: 80]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   244k|            else if constexpr( has_apply0_bool ) {
  153|   244k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   244k|            }
  155|   244k|         }
  156|   244k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 244k, False: 80]
  ------------------
  157|   244k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   244k|         }
  159|     80|         else {
  160|     80|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     80|         }
  162|   244k|         (void)m( result );
  163|   244k|         return result;
  164|   244k|      }
  165|   244k|   }
_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|   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_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|   244k|      {
   44|   244k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   244k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 100k, False: 143k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|   244k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 143k]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|   143k|         else {
  160|   143k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   143k|         }
  162|   244k|         (void)m( result );
  163|   244k|         return result;
  164|   244k|      }
  165|   244k|   }
_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|   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_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|   244k|      {
   44|   244k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   244k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 100k, False: 143k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|   244k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 143k]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|   143k|         else {
  160|   143k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   143k|         }
  162|   244k|         (void)m( result );
  163|   244k|         return result;
  164|   244k|      }
  165|   244k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   244k|      {
   59|   244k|         return Rule::match( in );
   60|   244k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   100k|   {
  104|   100k|      if constexpr( !Control< Rule >::enable ) {
  105|   100k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   100k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_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|   100k|      {
   44|   100k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   100k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   100k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   100k|      else {
  108|   100k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   100k|         using iterator_t = typename ParseInput::iterator_t;
  111|   100k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   100k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   100k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   100k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   100k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   100k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   100k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   100k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   100k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   100k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   100k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   100k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   100k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   100k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   100k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   100k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   100k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   100k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 100k, False: 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|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|   100k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 23]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|     23|         else {
  160|     23|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     23|         }
  162|   100k|         (void)m( result );
  163|   100k|         return result;
  164|   100k|      }
  165|   100k|   }
_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|   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_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|   100k|      {
   44|   100k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   100k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   201k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   201k|      else {
  108|   201k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   201k|         using iterator_t = typename ParseInput::iterator_t;
  111|   201k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   201k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   201k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   201k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   201k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   201k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   201k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   201k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   201k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   201k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   201k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   201k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   201k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   201k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   201k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   201k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   201k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   201k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201k, 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|   201k|            else if constexpr( has_apply0_bool ) {
  153|   201k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   201k|            }
  155|   201k|         }
  156|   201k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201k, False: 23]
  ------------------
  157|   201k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   201k|         }
  159|     23|         else {
  160|     23|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     23|         }
  162|   201k|         (void)m( result );
  163|   201k|         return result;
  164|   201k|      }
  165|   201k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   201k|      {
   73|   201k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   201k|         else {
   84|   201k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   201k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   201k|      }
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|   201k|      {
   59|   201k|         return Rule::match( in );
   60|   201k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.9k, False: 98.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.9k|            else if constexpr( has_apply0_bool ) {
  153|  44.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.9k|            }
  155|  44.9k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.9k, False: 98.4k]
  ------------------
  157|  44.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.9k|         }
  159|  98.4k|         else {
  160|  98.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  98.4k|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_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|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_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|   143k|      {
   44|   143k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   143k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   193k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   193k|      else {
  108|   193k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   193k|         using iterator_t = typename ParseInput::iterator_t;
  111|   193k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   193k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   193k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   193k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   193k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   193k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   193k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   193k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   193k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   193k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   193k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   193k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   193k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   193k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   193k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   193k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   193k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   193k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 53.8k, False: 139k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  53.8k|            else if constexpr( has_apply0_bool ) {
  153|  53.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  53.8k|            }
  155|  53.8k|         }
  156|   193k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 53.8k, False: 139k]
  ------------------
  157|  53.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  53.8k|         }
  159|   139k|         else {
  160|   139k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   139k|         }
  162|   193k|         (void)m( result );
  163|   193k|         return result;
  164|   193k|      }
  165|   193k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   193k|      {
   73|   193k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   193k|         else {
   84|   193k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   193k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   193k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   193k|      {
   59|   193k|         return Rule::match( in );
   60|   193k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  44.9k|   {
  104|  44.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  44.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|  44.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|  44.9k|      {
   44|  44.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.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|  44.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.9k|      else {
  108|  44.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.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|  44.9k|            else if constexpr( has_apply0_bool ) {
  153|  44.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.9k|            }
  155|  44.9k|         }
  156|  44.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.9k, False: 0]
  ------------------
  157|  44.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  44.9k|         (void)m( result );
  163|  44.9k|         return result;
  164|  44.9k|      }
  165|  44.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|  44.9k|      {
   73|  44.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|  44.9k|         else {
   84|  44.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.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|  44.9k|      {
   44|  44.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.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.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  98.4k|      else {
  108|  98.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  98.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  98.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|  98.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|  98.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|  98.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|  98.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|  98.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|  98.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  98.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  98.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  98.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|  98.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  98.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  98.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|  98.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  98.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  98.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  98.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  98.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 93.8k, False: 4.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|  93.8k|            else if constexpr( has_apply0_bool ) {
  153|  93.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  93.8k|            }
  155|  93.8k|         }
  156|  98.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 93.8k, False: 4.57k]
  ------------------
  157|  93.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  93.8k|         }
  159|  4.57k|         else {
  160|  4.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.57k|         }
  162|  98.4k|         (void)m( result );
  163|  98.4k|         return result;
  164|  98.4k|      }
  165|  98.4k|   }
_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.4k|      {
   73|  98.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|  98.4k|         else {
   84|  98.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  98.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  98.4k|      }
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.4k|      {
   59|  98.4k|         return Rule::match( in );
   60|  98.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.57k|      else {
  108|  4.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.57k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.57k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.57k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.57k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.57k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.57k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.57k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.52k, False: 57]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.52k|            else if constexpr( has_apply0_bool ) {
  153|  4.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.52k|            }
  155|  4.52k|         }
  156|  4.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.52k, False: 57]
  ------------------
  157|  4.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.52k|         }
  159|     57|         else {
  160|     57|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     57|         }
  162|  4.57k|         (void)m( result );
  163|  4.57k|         return result;
  164|  4.57k|      }
  165|  4.57k|   }
_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.57k|      {
   73|  4.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.57k|         else {
   84|  4.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.57k|      }
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.57k|      {
   59|  4.57k|         return Rule::match( in );
   60|  4.57k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.0M|      else {
  108|  16.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.0M, False: 217]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  16.0M|            else if constexpr( has_apply0_bool ) {
  153|  16.0M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.0M|            }
  155|  16.0M|         }
  156|  16.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.0M, False: 217]
  ------------------
  157|  16.0M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.0M|         }
  159|    217|         else {
  160|    217|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    217|         }
  162|  16.0M|         (void)m( result );
  163|  16.0M|         return result;
  164|  16.0M|      }
  165|  16.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.0M|      {
   73|  16.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|  16.0M|         else {
   84|  16.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.0M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.0M|      {
   59|  16.0M|         return Rule::match( in );
   60|  16.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.7k|      else {
  108|  40.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 37.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.73k|            else if constexpr( has_apply0_bool ) {
  153|  3.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.73k|            }
  155|  3.73k|         }
  156|  40.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 37.0k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  37.0k|         else {
  160|  37.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.0k|         }
  162|  40.7k|         (void)m( result );
  163|  40.7k|         return result;
  164|  40.7k|      }
  165|  40.7k|   }
_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|  40.7k|      {
   73|  40.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|  40.7k|         else {
   84|  40.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.7k|      }
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|  40.7k|      {
   44|  40.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.7k|      }
_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|  40.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.7k|      else {
  108|  40.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.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|  40.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|  40.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|  40.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|  40.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 37.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.73k|            else if constexpr( has_apply0_bool ) {
  153|  3.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.73k|            }
  155|  3.73k|         }
  156|  40.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 37.0k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  37.0k|         else {
  160|  37.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.0k|         }
  162|  40.7k|         (void)m( result );
  163|  40.7k|         return result;
  164|  40.7k|      }
  165|  40.7k|   }
_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|  40.7k|      {
   73|  40.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|  40.7k|         else {
   84|  40.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.7k|      }
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|  40.7k|      {
   44|  40.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.7k|      else {
  108|  40.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.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|  40.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|  40.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 40.7k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  40.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|  40.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|  40.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|  40.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.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|  40.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 40.7k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.49k, False: 36.2k]
  ------------------
  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|  40.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.49k, False: 36.2k]
  ------------------
  157|  4.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.49k|         }
  159|  36.2k|         else {
  160|  36.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.2k|         }
  162|  40.7k|         (void)m( result );
  163|  40.7k|         return result;
  164|  40.7k|      }
  165|  40.7k|   }
_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|  40.7k|      {
   73|  40.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|  40.7k|         else {
   84|  40.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.7k|      }
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|  40.7k|      {
   59|  40.7k|         return Rule::match( in );
   60|  40.7k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  13.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2k|      else {
  108|  13.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  13.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  13.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  13.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  13.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  13.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  13.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  13.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  13.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.9k, 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|  10.9k|            else if constexpr( has_apply0_bool ) {
  153|  10.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.9k|            }
  155|  10.9k|         }
  156|  13.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.9k, False: 2.36k]
  ------------------
  157|  10.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.9k|         }
  159|  2.36k|         else {
  160|  2.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.36k|         }
  162|  13.2k|         (void)m( result );
  163|  13.2k|         return result;
  164|  13.2k|      }
  165|  13.2k|   }
_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|  13.2k|      {
   73|  13.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  13.2k|         else {
   84|  13.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  13.2k|      {
   44|  13.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  13.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2k|      else {
  108|  13.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  13.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  13.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  13.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  13.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  13.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  13.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  13.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.2k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  13.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.9k, 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|  10.9k|            else if constexpr( has_apply0_bool ) {
  153|  10.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.9k|            }
  155|  10.9k|         }
  156|  13.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.9k, False: 2.36k]
  ------------------
  157|  10.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.9k|         }
  159|  2.36k|         else {
  160|  2.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.36k|         }
  162|  13.2k|         (void)m( result );
  163|  13.2k|         return result;
  164|  13.2k|      }
  165|  13.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  13.2k|      {
   73|  13.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  13.2k|         else {
   84|  13.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  13.2k|      {
   59|  13.2k|         return Rule::match( in );
   60|  13.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  22.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.7k|      else {
  108|  22.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.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|  22.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|  22.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|  22.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|  22.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|  22.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|  22.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.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|  22.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.52k, False: 17.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.52k|            else if constexpr( has_apply0_bool ) {
  153|  5.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.52k|            }
  155|  5.52k|         }
  156|  22.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.52k, False: 17.2k]
  ------------------
  157|  5.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.52k|         }
  159|  17.2k|         else {
  160|  17.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.2k|         }
  162|  22.7k|         (void)m( result );
  163|  22.7k|         return result;
  164|  22.7k|      }
  165|  22.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  22.7k|      {
   73|  22.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|  22.7k|         else {
   84|  22.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  22.7k|      {
   59|  22.7k|         return Rule::match( in );
   60|  22.7k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 737]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.73k|            else if constexpr( has_apply0_bool ) {
  153|  3.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.73k|            }
  155|  3.73k|         }
  156|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 737]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|    737|         else {
  160|    737|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    737|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   44|  4.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.47k|      }
_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.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 1.50k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.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|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 1.50k]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   44|  4.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.47k|      }
_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.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.47k, 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.47k|            else if constexpr( has_apply0_bool ) {
  153|  4.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.47k|            }
  155|  4.47k|         }
  156|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.47k, False: 0]
  ------------------
  157|  4.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.47k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   44|  4.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.47k|      }
_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.47k|   {
  104|  4.47k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.47k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.47k|   }
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.47k|      {
   44|  4.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.47k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.47k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.22k, False: 2.25k]
  ------------------
  143|  2.22k|            if constexpr( has_apply_void ) {
  144|  2.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|  2.22k|         }
  156|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.22k, False: 2.25k]
  ------------------
  157|  2.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.22k|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   44|  4.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.47k|      }
_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.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 349, False: 4.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|    349|            else if constexpr( has_apply0_bool ) {
  153|    349|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    349|            }
  155|    349|         }
  156|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 349, False: 4.12k]
  ------------------
  157|    349|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    349|         }
  159|  4.12k|         else {
  160|  4.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.12k|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   59|  4.47k|         return Rule::match( in );
   60|  4.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.12k|      else {
  108|  4.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 648, False: 3.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    648|            else if constexpr( has_apply0_bool ) {
  153|    648|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    648|            }
  155|    648|         }
  156|  4.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 648, False: 3.47k]
  ------------------
  157|    648|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    648|         }
  159|  3.47k|         else {
  160|  3.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.47k|         }
  162|  4.12k|         (void)m( result );
  163|  4.12k|         return result;
  164|  4.12k|      }
  165|  4.12k|   }
_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|  4.12k|      {
   73|  4.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|  4.12k|         else {
   84|  4.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.12k|      }
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|  4.12k|      {
   59|  4.12k|         return Rule::match( in );
   60|  4.12k|      }
_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.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.47k|      else {
  108|  3.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 349, False: 3.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|    349|            else if constexpr( has_apply0_bool ) {
  153|    349|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    349|            }
  155|    349|         }
  156|  3.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 349, False: 3.12k]
  ------------------
  157|    349|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    349|         }
  159|  3.12k|         else {
  160|  3.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.12k|         }
  162|  3.47k|         (void)m( result );
  163|  3.47k|         return result;
  164|  3.47k|      }
  165|  3.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.47k|      {
   73|  3.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.47k|         else {
   84|  3.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.47k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.47k|      {
   59|  3.47k|         return Rule::match( in );
   60|  3.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.12k|      else {
  108|  3.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.12k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 198, False: 2.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|    198|            else if constexpr( has_apply0_bool ) {
  153|    198|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    198|            }
  155|    198|         }
  156|  3.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 198, False: 2.93k]
  ------------------
  157|    198|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    198|         }
  159|  2.93k|         else {
  160|  2.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.93k|         }
  162|  3.12k|         (void)m( result );
  163|  3.12k|         return result;
  164|  3.12k|      }
  165|  3.12k|   }
_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.12k|      {
   73|  3.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.12k|         else {
   84|  3.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.12k|      {
   59|  3.12k|         return Rule::match( in );
   60|  3.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.93k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.93k|      else {
  108|  2.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.93k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.93k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 252, 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|    252|            else if constexpr( has_apply0_bool ) {
  153|    252|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    252|            }
  155|    252|         }
  156|  2.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 252, False: 2.67k]
  ------------------
  157|    252|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    252|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  2.93k|         (void)m( result );
  163|  2.93k|         return result;
  164|  2.93k|      }
  165|  2.93k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.93k|      {
   73|  2.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|  2.93k|         else {
   84|  2.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.93k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.93k|      {
   59|  2.93k|         return Rule::match( in );
   60|  2.93k|      }
_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.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.67k|      else {
  108|  2.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.67k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.67k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.67k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 428, 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|    428|            else if constexpr( has_apply0_bool ) {
  153|    428|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    428|            }
  155|    428|         }
  156|  2.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 428, False: 2.25k]
  ------------------
  157|    428|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    428|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|  2.67k|         (void)m( result );
  163|  2.67k|         return result;
  164|  2.67k|      }
  165|  2.67k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.67k|      {
   73|  2.67k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.67k|         else {
   84|  2.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.67k|      {
   59|  2.67k|         return Rule::match( in );
   60|  2.67k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.47k|      else {
  108|  4.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.20k, False: 1.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.20k|            else if constexpr( has_apply0_bool ) {
  153|  3.20k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.20k|            }
  155|  3.20k|         }
  156|  4.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.20k, False: 1.27k]
  ------------------
  157|  3.20k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.20k|         }
  159|  1.27k|         else {
  160|  1.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.27k|         }
  162|  4.47k|         (void)m( result );
  163|  4.47k|         return result;
  164|  4.47k|      }
  165|  4.47k|   }
_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.47k|      {
   73|  4.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.47k|         else {
   84|  4.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.47k|      }
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.47k|      {
   59|  4.47k|         return Rule::match( in );
   60|  4.47k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.31k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.31k|      else {
  108|  6.31k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.31k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.31k|         constexpr bool has_apply_void = enable_action && internal::has_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.31k|         constexpr bool has_apply_bool = enable_action && internal::has_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.31k|         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.31k|         constexpr bool has_apply0_void = enable_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.31k|         constexpr bool has_apply0_bool = enable_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.31k|         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.31k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.31k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.31k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.31k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.31k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.31k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.31k|         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.31k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.31k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.31k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.31k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.31k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.31k, 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.31k|            else if constexpr( has_apply0_bool ) {
  153|  6.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.31k|            }
  155|  6.31k|         }
  156|  6.31k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.31k, False: 0]
  ------------------
  157|  6.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.31k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.31k|         (void)m( result );
  163|  6.31k|         return result;
  164|  6.31k|      }
  165|  6.31k|   }
_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|  6.31k|      {
   73|  6.31k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.31k|         else {
   84|  6.31k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.31k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.31k|      }
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|  6.31k|      {
   44|  6.31k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.31k|      }
_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|  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: 3.11k, 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|  3.11k|            else if constexpr( has_apply0_bool ) {
  153|  3.11k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.11k|            }
  155|  3.11k|         }
  156|  3.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.11k, False: 89]
  ------------------
  157|  3.11k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.11k|         }
  159|     89|         else {
  160|     89|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     89|         }
  162|  3.20k|         (void)m( result );
  163|  3.20k|         return result;
  164|  3.20k|      }
  165|  3.20k|   }
_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|  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_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|  3.20k|      {
   44|  3.20k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.20k|      }
_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|  3.13k|   {
  104|  3.13k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.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|  3.13k|   }
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|  3.13k|      {
   44|  3.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.13k|      }
_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.55k|   {
  104|  6.55k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.55k|   }
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.55k|      {
   44|  6.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.55k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.11k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.11k|      else {
  108|  3.11k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.11k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.11k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.11k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.11k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.11k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.11k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.11k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.11k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.11k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.11k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.11k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.11k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.11k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.11k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.11k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.11k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.11k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.11k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.11k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, 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|  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.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 147]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|    147|         else {
  160|    147|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    147|         }
  162|  3.11k|         (void)m( result );
  163|  3.11k|         return result;
  164|  3.11k|      }
  165|  3.11k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.11k|      {
   73|  3.11k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.11k|         else {
   84|  3.11k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.11k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.11k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.11k|      {
   59|  3.11k|         return Rule::match( in );
   60|  3.11k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.92k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.92k|      else {
  108|  8.92k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.92k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.92k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.92k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.92k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.92k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.92k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.92k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.92k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.92k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.92k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.92k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.92k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.92k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.92k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.92k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.92k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.92k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.92k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.92k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.92k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.92k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.38k, False: 1.54k]
  ------------------
  143|  7.38k|            if constexpr( has_apply_void ) {
  144|  7.38k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  7.38k|         }
  156|  8.92k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.32k, False: 1.59k]
  ------------------
  157|  7.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.32k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  8.92k|         (void)m( result );
  163|  8.92k|         return result;
  164|  8.92k|      }
  165|  8.92k|   }
_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.92k|      {
   73|  8.92k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.92k|         else {
   84|  8.92k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.92k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.92k|      }
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.92k|      {
   44|  8.92k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.92k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.92k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.92k|      else {
  108|  8.92k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.92k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.92k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.92k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.92k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.92k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.92k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.92k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.92k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.92k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.92k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.92k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.92k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.92k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.92k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.92k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.92k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.92k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.92k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.92k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.69k, 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.69k|            else if constexpr( has_apply0_bool ) {
  153|  7.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.69k|            }
  155|  7.69k|         }
  156|  8.92k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.69k, False: 1.23k]
  ------------------
  157|  7.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.69k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  8.92k|         (void)m( result );
  163|  8.92k|         return result;
  164|  8.92k|      }
  165|  8.92k|   }
_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.92k|      {
   73|  8.92k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.92k|         else {
   84|  8.92k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.92k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.92k|      }
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.92k|      {
   59|  8.92k|         return Rule::match( in );
   60|  8.92k|      }
_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.69k|   {
  104|  7.69k|      if constexpr( !Control< Rule >::enable ) {
  105|  7.69k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  7.69k|   }
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.69k|      {
   44|  7.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.69k|      }
_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.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.69k|      else {
  108|  7.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.69k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.38k, False: 313]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.38k|            else if constexpr( has_apply0_bool ) {
  153|  7.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.38k|            }
  155|  7.38k|         }
  156|  7.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.38k, False: 313]
  ------------------
  157|  7.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.38k|         }
  159|    313|         else {
  160|    313|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    313|         }
  162|  7.69k|         (void)m( result );
  163|  7.69k|         return result;
  164|  7.69k|      }
  165|  7.69k|   }
_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.69k|      {
   73|  7.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.69k|         else {
   84|  7.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.69k|      }
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.69k|      {
   44|  7.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.69k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.91M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.91M|      else {
  108|  6.91M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.91M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.91M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.91M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.91M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.91M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.91M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.91M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.91M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.91M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.91M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.91M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.91M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.91M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.91M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.91M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.91M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.91M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.91M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.91M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.38k, False: 6.90M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.38k|            else if constexpr( has_apply0_bool ) {
  153|  7.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.38k|            }
  155|  7.38k|         }
  156|  6.91M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.38k, False: 6.90M]
  ------------------
  157|  7.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.38k|         }
  159|  6.90M|         else {
  160|  6.90M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.90M|         }
  162|  6.91M|         (void)m( result );
  163|  6.91M|         return result;
  164|  6.91M|      }
  165|  6.91M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.91M|      {
   73|  6.91M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.91M|         else {
   84|  6.91M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.91M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.91M|      }
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|  6.91M|      {
   59|  6.91M|         return Rule::match( in );
   60|  6.91M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.90M|      else {
  108|  6.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.90M, False: 313]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.90M|            else if constexpr( has_apply0_bool ) {
  153|  6.90M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.90M|            }
  155|  6.90M|         }
  156|  6.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.90M, False: 313]
  ------------------
  157|  6.90M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.90M|         }
  159|    313|         else {
  160|    313|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    313|         }
  162|  6.90M|         (void)m( result );
  163|  6.90M|         return result;
  164|  6.90M|      }
  165|  6.90M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.90M|      {
   73|  6.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.90M|         else {
   84|  6.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.90M|      }
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|  6.90M|      {
   44|  6.90M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.90M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.90M|      else {
  108|  6.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 76.2k, False: 6.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|  76.2k|            else if constexpr( has_apply0_bool ) {
  153|  76.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  76.2k|            }
  155|  76.2k|         }
  156|  6.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 76.2k, False: 6.83M]
  ------------------
  157|  76.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  76.2k|         }
  159|  6.83M|         else {
  160|  6.83M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.83M|         }
  162|  6.90M|         (void)m( result );
  163|  6.90M|         return result;
  164|  6.90M|      }
  165|  6.90M|   }
_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|  6.90M|      {
   73|  6.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.90M|         else {
   84|  6.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.90M|      }
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|  6.90M|      {
   44|  6.90M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.90M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.90M|      else {
  108|  6.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 76.3k, False: 6.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|  76.3k|            else if constexpr( has_apply0_bool ) {
  153|  76.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  76.3k|            }
  155|  76.3k|         }
  156|  6.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 76.3k, False: 6.83M]
  ------------------
  157|  76.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  76.3k|         }
  159|  6.83M|         else {
  160|  6.83M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.83M|         }
  162|  6.90M|         (void)m( result );
  163|  6.90M|         return result;
  164|  6.90M|      }
  165|  6.90M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.90M|      {
   73|  6.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.90M|         else {
   84|  6.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.90M|      }
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|  6.90M|      {
   59|  6.90M|         return Rule::match( in );
   60|  6.90M|      }
_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|  76.3k|   {
  104|  76.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  76.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|  76.3k|   }
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|  76.3k|      {
   44|  76.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  76.3k|      }
_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|  76.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  76.3k|      else {
  108|  76.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  76.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  76.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|  76.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|  76.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|  76.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|  76.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|  76.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|  76.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  76.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  76.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  76.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|  76.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  76.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  76.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|  76.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  76.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  76.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  76.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  76.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 76.2k, 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|  76.2k|            else if constexpr( has_apply0_bool ) {
  153|  76.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  76.2k|            }
  155|  76.2k|         }
  156|  76.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 76.2k, False: 105]
  ------------------
  157|  76.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  76.2k|         }
  159|    105|         else {
  160|    105|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    105|         }
  162|  76.3k|         (void)m( result );
  163|  76.3k|         return result;
  164|  76.3k|      }
  165|  76.3k|   }
_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|  76.3k|      {
   73|  76.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|  76.3k|         else {
   84|  76.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  76.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  76.3k|      }
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|  76.3k|      {
   44|  76.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  76.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  76.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  76.3k|      else {
  108|  76.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  76.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  76.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|  76.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|  76.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|  76.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|  76.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|  76.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|  76.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  76.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  76.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  76.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|  76.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  76.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  76.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|  76.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  76.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  76.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  76.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  76.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.3k, False: 55.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|  20.3k|            else if constexpr( has_apply0_bool ) {
  153|  20.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.3k|            }
  155|  20.3k|         }
  156|  76.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.3k, False: 55.9k]
  ------------------
  157|  20.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.3k|         }
  159|  55.9k|         else {
  160|  55.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.9k|         }
  162|  76.3k|         (void)m( result );
  163|  76.3k|         return result;
  164|  76.3k|      }
  165|  76.3k|   }
_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|  76.3k|      {
   73|  76.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|  76.3k|         else {
   84|  76.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  76.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  76.3k|      }
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|  76.3k|      {
   44|  76.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  76.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  76.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  76.3k|      else {
  108|  76.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  76.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  76.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|  76.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|  76.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|  76.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|  76.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|  76.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|  76.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  76.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  76.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  76.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|  76.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  76.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  76.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|  76.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  76.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  76.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  76.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  76.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.4k, False: 55.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|  20.4k|            else if constexpr( has_apply0_bool ) {
  153|  20.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.4k|            }
  155|  20.4k|         }
  156|  76.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.4k, False: 55.9k]
  ------------------
  157|  20.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.4k|         }
  159|  55.9k|         else {
  160|  55.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.9k|         }
  162|  76.3k|         (void)m( result );
  163|  76.3k|         return result;
  164|  76.3k|      }
  165|  76.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  76.3k|      {
   73|  76.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|  76.3k|         else {
   84|  76.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  76.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  76.3k|      }
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|  76.3k|      {
   59|  76.3k|         return Rule::match( in );
   60|  76.3k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  20.4k|   {
  104|  20.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  20.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  20.4k|   }
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|  20.4k|      {
   44|  20.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.4k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  20.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.4k|      else {
  108|  20.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.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|  20.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|  20.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|  20.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|  20.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|  20.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|  20.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.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|  20.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.3k, 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|  20.3k|            else if constexpr( has_apply0_bool ) {
  153|  20.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.3k|            }
  155|  20.3k|         }
  156|  20.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.3k, False: 47]
  ------------------
  157|  20.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.3k|         }
  159|     47|         else {
  160|     47|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     47|         }
  162|  20.4k|         (void)m( result );
  163|  20.4k|         return result;
  164|  20.4k|      }
  165|  20.4k|   }
_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|  20.4k|      {
   73|  20.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|  20.4k|         else {
   84|  20.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.4k|      }
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|  20.4k|      {
   44|  20.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  40.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.8k|      else {
  108|  40.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  40.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  40.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  40.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  40.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  40.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  40.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  40.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  40.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 40.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|  40.7k|            else if constexpr( has_apply0_bool ) {
  153|  40.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.7k|            }
  155|  40.7k|         }
  156|  40.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.7k, False: 47]
  ------------------
  157|  40.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.7k|         }
  159|     47|         else {
  160|     47|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     47|         }
  162|  40.8k|         (void)m( result );
  163|  40.8k|         return result;
  164|  40.8k|      }
  165|  40.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  40.8k|      {
   73|  40.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  40.8k|         else {
   84|  40.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  40.8k|      {
   59|  40.8k|         return Rule::match( in );
   60|  40.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  55.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  55.9k|      else {
  108|  55.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  55.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  55.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  55.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  55.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|  55.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|  55.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|  55.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|  55.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  55.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  55.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  55.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  55.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  55.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  55.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  55.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  55.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  55.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  55.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.4k, False: 23.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  32.4k|            else if constexpr( has_apply0_bool ) {
  153|  32.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.4k|            }
  155|  32.4k|         }
  156|  55.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.4k, False: 23.4k]
  ------------------
  157|  32.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.4k|         }
  159|  23.4k|         else {
  160|  23.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.4k|         }
  162|  55.9k|         (void)m( result );
  163|  55.9k|         return result;
  164|  55.9k|      }
  165|  55.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  55.9k|      {
   73|  55.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.9k|         else {
   84|  55.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  55.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  55.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_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|  55.9k|      {
   44|  55.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  55.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  92.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  92.2k|      else {
  108|  92.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  92.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  92.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|  92.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|  92.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|  92.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|  92.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|  92.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|  92.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  92.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  92.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  92.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|  92.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  92.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  92.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|  92.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  92.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  92.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  92.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  92.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.2k, False: 53.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|  39.2k|            else if constexpr( has_apply0_bool ) {
  153|  39.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.2k|            }
  155|  39.2k|         }
  156|  92.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.2k, False: 53.0k]
  ------------------
  157|  39.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.2k|         }
  159|  53.0k|         else {
  160|  53.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  53.0k|         }
  162|  92.2k|         (void)m( result );
  163|  92.2k|         return result;
  164|  92.2k|      }
  165|  92.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  92.2k|      {
   73|  92.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|  92.2k|         else {
   84|  92.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  92.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  92.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  92.2k|      {
   59|  92.2k|         return Rule::match( in );
   60|  92.2k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  32.4k|   {
  104|  32.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  32.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  32.4k|   }
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|  32.4k|      {
   44|  32.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.4k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  32.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  32.4k|      else {
  108|  32.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  32.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  32.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  32.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  32.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  32.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  32.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  32.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  32.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  32.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.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|  32.4k|            else if constexpr( has_apply0_bool ) {
  153|  32.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.4k|            }
  155|  32.4k|         }
  156|  32.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.4k, False: 0]
  ------------------
  157|  32.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  32.4k|         (void)m( result );
  163|  32.4k|         return result;
  164|  32.4k|      }
  165|  32.4k|   }
_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|  32.4k|      {
   73|  32.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  32.4k|         else {
   84|  32.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  32.4k|      {
   44|  32.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  23.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  23.4k|      else {
  108|  23.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  23.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  23.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|  23.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|  23.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|  23.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|  23.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|  23.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|  23.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  23.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  23.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  23.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|  23.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  23.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  23.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|  23.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  23.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  23.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  23.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  23.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 23.1k, False: 359]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.1k|            else if constexpr( has_apply0_bool ) {
  153|  23.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  23.1k|            }
  155|  23.1k|         }
  156|  23.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 23.1k, False: 359]
  ------------------
  157|  23.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  23.1k|         }
  159|    359|         else {
  160|    359|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    359|         }
  162|  23.4k|         (void)m( result );
  163|  23.4k|         return result;
  164|  23.4k|      }
  165|  23.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  23.4k|      {
   73|  23.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|  23.4k|         else {
   84|  23.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  23.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  23.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  23.4k|      {
   59|  23.4k|         return Rule::match( in );
   60|  23.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    359|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    359|      else {
  108|    359|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    359|         using iterator_t = typename ParseInput::iterator_t;
  111|    359|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    359|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    359|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    359|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    359|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    359|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    359|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    359|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    359|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    359|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    359|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    359|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    359|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    359|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    359|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    359|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    359|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    359|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 301, 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|    301|            else if constexpr( has_apply0_bool ) {
  153|    301|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    301|            }
  155|    301|         }
  156|    359|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 301, False: 58]
  ------------------
  157|    301|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    301|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|    359|         (void)m( result );
  163|    359|         return result;
  164|    359|      }
  165|    359|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    359|      {
   73|    359|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    359|         else {
   84|    359|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    359|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    359|      }
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|    359|      {
   59|    359|         return Rule::match( in );
   60|    359|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.83M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.83M|      else {
  108|  6.83M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.83M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.83M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.83M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.83M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.83M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.83M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.83M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.83M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.83M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.83M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.83M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.83M, False: 208]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.83M|            else if constexpr( has_apply0_bool ) {
  153|  6.83M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.83M|            }
  155|  6.83M|         }
  156|  6.83M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.83M, False: 208]
  ------------------
  157|  6.83M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.83M|         }
  159|    208|         else {
  160|    208|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    208|         }
  162|  6.83M|         (void)m( result );
  163|  6.83M|         return result;
  164|  6.83M|      }
  165|  6.83M|   }
_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|  6.83M|      {
   73|  6.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|  6.83M|         else {
   84|  6.83M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.83M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.83M|      }
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|  6.83M|      {
   59|  6.83M|         return Rule::match( in );
   60|  6.83M|      }
_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|  36.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.6k|      else {
  108|  36.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.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|  36.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|  36.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|  36.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|  36.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|  36.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|  36.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.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|  36.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.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|  36.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 34.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.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|  36.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 34.1k]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|  34.1k|         else {
  160|  34.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.1k|         }
  162|  36.6k|         (void)m( result );
  163|  36.6k|         return result;
  164|  36.6k|      }
  165|  36.6k|   }
_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|  36.6k|      {
   73|  36.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|  36.6k|         else {
   84|  36.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.6k|      }
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|  36.6k|      {
   44|  36.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.6k|      }
_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|  36.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.6k|      else {
  108|  36.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.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|  36.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|  36.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|  36.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|  36.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|  36.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|  36.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.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|  36.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.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|  36.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 34.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.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|  36.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 34.1k]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|  34.1k|         else {
  160|  34.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.1k|         }
  162|  36.6k|         (void)m( result );
  163|  36.6k|         return result;
  164|  36.6k|      }
  165|  36.6k|   }
_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|  36.6k|      {
   73|  36.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|  36.6k|         else {
   84|  36.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.6k|      }
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|  36.6k|      {
   44|  36.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.6k|      }
_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|  36.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.6k|      else {
  108|  36.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.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|  36.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|  36.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 36.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  36.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|  36.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|  36.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|  36.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.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|  36.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.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|  36.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 36.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.17k, False: 33.4k]
  ------------------
  143|  3.17k|            if constexpr( has_apply_void ) {
  144|  3.17k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.17k|         }
  156|  36.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.17k, False: 33.4k]
  ------------------
  157|  3.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.17k|         }
  159|  33.4k|         else {
  160|  33.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.4k|         }
  162|  36.6k|         (void)m( result );
  163|  36.6k|         return result;
  164|  36.6k|      }
  165|  36.6k|   }
_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|  36.6k|      {
   73|  36.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|  36.6k|         else {
   84|  36.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.6k|      }
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|  36.6k|      {
   59|  36.6k|         return Rule::match( in );
   60|  36.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.26k|      else {
  108|  9.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.65k, 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|  7.65k|            else if constexpr( has_apply0_bool ) {
  153|  7.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.65k|            }
  155|  7.65k|         }
  156|  9.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.65k, False: 1.61k]
  ------------------
  157|  7.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.65k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  9.26k|         (void)m( result );
  163|  9.26k|         return result;
  164|  9.26k|      }
  165|  9.26k|   }
_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|  9.26k|      {
   73|  9.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.26k|         else {
   84|  9.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  9.26k|      {
   44|  9.26k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.26k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.26k|      else {
  108|  9.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.26k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.26k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.26k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.26k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.65k, 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|  7.65k|            else if constexpr( has_apply0_bool ) {
  153|  7.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.65k|            }
  155|  7.65k|         }
  156|  9.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.65k, False: 1.61k]
  ------------------
  157|  7.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.65k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  9.26k|         (void)m( result );
  163|  9.26k|         return result;
  164|  9.26k|      }
  165|  9.26k|   }
_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|  9.26k|      {
   73|  9.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.26k|         else {
   84|  9.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.26k|      {
   59|  9.26k|         return Rule::match( in );
   60|  9.26k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.6k|      else {
  108|  15.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  15.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  15.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  15.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  15.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  15.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  15.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  15.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  15.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.88k, False: 11.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.88k|            else if constexpr( has_apply0_bool ) {
  153|  3.88k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.88k|            }
  155|  3.88k|         }
  156|  15.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.88k, False: 11.8k]
  ------------------
  157|  3.88k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.88k|         }
  159|  11.8k|         else {
  160|  11.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.8k|         }
  162|  15.6k|         (void)m( result );
  163|  15.6k|         return result;
  164|  15.6k|      }
  165|  15.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  15.6k|      {
   73|  15.6k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  15.6k|         else {
   84|  15.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  15.6k|      {
   59|  15.6k|         return Rule::match( in );
   60|  15.6k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.54k, False: 616]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.54k, False: 616]
  ------------------
  157|  2.54k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.54k|         }
  159|    616|         else {
  160|    616|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    616|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_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.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 1.23k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.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.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 1.23k]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_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.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.15k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.15k|            else if constexpr( has_apply0_bool ) {
  153|  3.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.15k|            }
  155|  3.15k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.15k, False: 0]
  ------------------
  157|  3.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.15k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_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.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|  3.15k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.15k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.15k|   }
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.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_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.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.15k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.15k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.16k, False: 1.99k]
  ------------------
  143|  1.16k|            if constexpr( has_apply_void ) {
  144|  1.16k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.16k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.16k, False: 1.99k]
  ------------------
  157|  1.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.16k|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_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.15k|      {
   73|  3.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|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_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.15k|      {
   44|  3.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.15k|      }
_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.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 220, False: 2.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|    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.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 220, False: 2.93k]
  ------------------
  157|    220|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    220|         }
  159|  2.93k|         else {
  160|  2.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.93k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.15k|      {
   73|  3.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.15k|      {
   59|  3.15k|         return Rule::match( in );
   60|  3.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.93k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.93k|      else {
  108|  2.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.93k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.93k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 199, False: 2.73k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    199|            else if constexpr( has_apply0_bool ) {
  153|    199|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    199|            }
  155|    199|         }
  156|  2.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 199, False: 2.73k]
  ------------------
  157|    199|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    199|         }
  159|  2.73k|         else {
  160|  2.73k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.73k|         }
  162|  2.93k|         (void)m( result );
  163|  2.93k|         return result;
  164|  2.93k|      }
  165|  2.93k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.93k|      {
   73|  2.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|  2.93k|         else {
   84|  2.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.93k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.93k|      {
   59|  2.93k|         return Rule::match( in );
   60|  2.93k|      }
_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.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.73k|      else {
  108|  2.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.73k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.73k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.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|  2.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|  2.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|  2.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|  2.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.73k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.73k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, 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|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.54k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.54k|         else {
  160|  2.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.54k|         }
  162|  2.73k|         (void)m( result );
  163|  2.73k|         return result;
  164|  2.73k|      }
  165|  2.73k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.73k|      {
   73|  2.73k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.73k|         else {
   84|  2.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.73k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.73k|      {
   59|  2.73k|         return Rule::match( in );
   60|  2.73k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.54k|      else {
  108|  2.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.54k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.54k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.54k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.54k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.54k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.54k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, False: 2.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.34k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.34k|         else {
  160|  2.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.34k|         }
  162|  2.54k|         (void)m( result );
  163|  2.54k|         return result;
  164|  2.54k|      }
  165|  2.54k|   }
_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.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_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.54k|      {
   59|  2.54k|         return Rule::match( in );
   60|  2.54k|      }
_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.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.34k|      else {
  108|  2.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.34k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 271, False: 2.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  2.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 271, False: 2.07k]
  ------------------
  157|    271|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    271|         }
  159|  2.07k|         else {
  160|  2.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.07k|         }
  162|  2.34k|         (void)m( result );
  163|  2.34k|         return result;
  164|  2.34k|      }
  165|  2.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.34k|      {
   73|  2.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.34k|         else {
   84|  2.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.34k|      {
   59|  2.34k|         return Rule::match( in );
   60|  2.34k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.07k|      else {
  108|  2.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 82, False: 1.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|     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|  2.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 82, False: 1.99k]
  ------------------
  157|     82|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     82|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  2.07k|         (void)m( result );
  163|  2.07k|         return result;
  164|  2.07k|      }
  165|  2.07k|   }
_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.07k|      {
   73|  2.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.07k|         else {
   84|  2.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.07k|      }
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.07k|      {
   59|  2.07k|         return Rule::match( in );
   60|  2.07k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.15k|      else {
  108|  3.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.15k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.10k, False: 1.05k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.10k|            else if constexpr( has_apply0_bool ) {
  153|  2.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.10k|            }
  155|  2.10k|         }
  156|  3.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.10k, False: 1.05k]
  ------------------
  157|  2.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.10k|         }
  159|  1.05k|         else {
  160|  1.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.05k|         }
  162|  3.15k|         (void)m( result );
  163|  3.15k|         return result;
  164|  3.15k|      }
  165|  3.15k|   }
_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.15k|      {
   73|  3.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|  3.15k|         else {
   84|  3.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.15k|      {
   59|  3.15k|         return Rule::match( in );
   60|  3.15k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.15k|      else {
  108|  4.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.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|  4.15k|            else if constexpr( has_apply0_bool ) {
  153|  4.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.15k|            }
  155|  4.15k|         }
  156|  4.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.15k, False: 0]
  ------------------
  157|  4.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.15k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.15k|         (void)m( result );
  163|  4.15k|         return result;
  164|  4.15k|      }
  165|  4.15k|   }
_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.15k|      {
   73|  4.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|  4.15k|         else {
   84|  4.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.15k|      }
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.15k|      {
   44|  4.15k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.15k|      }
_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.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.10k|      else {
  108|  2.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.04k, False: 62]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.04k|            else if constexpr( has_apply0_bool ) {
  153|  2.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.04k|            }
  155|  2.04k|         }
  156|  2.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.04k, False: 62]
  ------------------
  157|  2.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.04k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|  2.10k|         (void)m( result );
  163|  2.10k|         return result;
  164|  2.10k|      }
  165|  2.10k|   }
_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.10k|      {
   73|  2.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.10k|         else {
   84|  2.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.10k|      {
   44|  2.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.10k|      }
_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.05k|   {
  104|  2.05k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.05k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.05k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_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.05k|      {
   44|  2.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.05k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.93k|   {
  104|  4.93k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.93k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.93k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.93k|      {
   44|  4.93k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.93k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.04k|      else {
  108|  2.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 122]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 122]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|    122|         else {
  160|    122|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    122|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_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.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.04k|         else {
   84|  2.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.04k|      {
   59|  2.04k|         return Rule::match( in );
   60|  2.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.70k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.70k|      else {
  108|  6.70k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.70k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.70k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.70k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.70k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.70k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.70k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.70k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.70k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.70k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.70k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.70k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.70k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.70k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.70k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.70k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.70k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.70k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.70k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.70k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.70k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.70k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.60k, False: 1.10k]
  ------------------
  143|  5.60k|            if constexpr( has_apply_void ) {
  144|  5.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|  5.60k|         }
  156|  6.70k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.55k, False: 1.15k]
  ------------------
  157|  5.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.55k|         }
  159|  1.15k|         else {
  160|  1.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15k|         }
  162|  6.70k|         (void)m( result );
  163|  6.70k|         return result;
  164|  6.70k|      }
  165|  6.70k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.70k|      {
   73|  6.70k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.70k|         else {
   84|  6.70k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.70k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.70k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.70k|      {
   44|  6.70k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.70k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.70k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.70k|      else {
  108|  6.70k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.70k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.70k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.70k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.70k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.70k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.70k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.70k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.70k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.70k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.70k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.70k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.70k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.70k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.70k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.70k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.70k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.70k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.70k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.70k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.86k, False: 843]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.86k|            else if constexpr( has_apply0_bool ) {
  153|  5.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.86k|            }
  155|  5.86k|         }
  156|  6.70k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.86k, False: 843]
  ------------------
  157|  5.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.86k|         }
  159|    843|         else {
  160|    843|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    843|         }
  162|  6.70k|         (void)m( result );
  163|  6.70k|         return result;
  164|  6.70k|      }
  165|  6.70k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.70k|      {
   73|  6.70k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.70k|         else {
   84|  6.70k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.70k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.70k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.70k|      {
   59|  6.70k|         return Rule::match( in );
   60|  6.70k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.86k|   {
  104|  5.86k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.86k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.86k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.86k|      {
   44|  5.86k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.86k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.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: 5.60k, False: 260]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.60k|            else if constexpr( has_apply0_bool ) {
  153|  5.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.60k|            }
  155|  5.60k|         }
  156|  5.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.60k, False: 260]
  ------------------
  157|  5.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.60k|         }
  159|    260|         else {
  160|    260|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    260|         }
  162|  5.86k|         (void)m( result );
  163|  5.86k|         return result;
  164|  5.86k|      }
  165|  5.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.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_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.86k|      {
   44|  5.86k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.86k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.03M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.03M|      else {
  108|  6.03M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.03M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.03M|         constexpr bool has_apply_void = enable_action && internal::has_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.03M|         constexpr bool has_apply_bool = enable_action && internal::has_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.03M|         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.03M|         constexpr bool has_apply0_void = enable_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.03M|         constexpr bool has_apply0_bool = enable_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.03M|         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.03M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.03M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.03M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.03M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.03M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.03M|         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.03M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.03M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.03M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.03M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.03M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.60k, False: 6.02M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.60k|            else if constexpr( has_apply0_bool ) {
  153|  5.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.60k|            }
  155|  5.60k|         }
  156|  6.03M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.60k, False: 6.02M]
  ------------------
  157|  5.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.60k|         }
  159|  6.02M|         else {
  160|  6.02M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.02M|         }
  162|  6.03M|         (void)m( result );
  163|  6.03M|         return result;
  164|  6.03M|      }
  165|  6.03M|   }
_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|  6.03M|      {
   73|  6.03M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03M|         else {
   84|  6.03M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.03M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.03M|      }
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|  6.03M|      {
   59|  6.03M|         return Rule::match( in );
   60|  6.03M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.02M|      else {
  108|  6.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.02M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.02M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.02M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.02M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.02M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.02M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.02M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.02M, False: 260]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.02M|            else if constexpr( has_apply0_bool ) {
  153|  6.02M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.02M|            }
  155|  6.02M|         }
  156|  6.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.02M, False: 260]
  ------------------
  157|  6.02M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.02M|         }
  159|    260|         else {
  160|    260|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    260|         }
  162|  6.02M|         (void)m( result );
  163|  6.02M|         return result;
  164|  6.02M|      }
  165|  6.02M|   }
_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|  6.02M|      {
   73|  6.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.02M|         else {
   84|  6.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.02M|      }
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|  6.02M|      {
   44|  6.02M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.02M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.02M|      else {
  108|  6.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.02M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.02M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.02M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.02M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.02M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.02M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.02M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 85.9k, False: 5.93M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  85.9k|            else if constexpr( has_apply0_bool ) {
  153|  85.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  85.9k|            }
  155|  85.9k|         }
  156|  6.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 85.9k, False: 5.93M]
  ------------------
  157|  85.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  85.9k|         }
  159|  5.93M|         else {
  160|  5.93M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.93M|         }
  162|  6.02M|         (void)m( result );
  163|  6.02M|         return result;
  164|  6.02M|      }
  165|  6.02M|   }
_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|  6.02M|      {
   73|  6.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.02M|         else {
   84|  6.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.02M|      }
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|  6.02M|      {
   44|  6.02M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.02M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.02M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.02M|      else {
  108|  6.02M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.02M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.02M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.02M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.02M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.02M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.02M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.02M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.02M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.02M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.02M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.02M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.02M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.02M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.02M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.02M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.02M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.02M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.02M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.02M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 85.9k, False: 5.93M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  85.9k|            else if constexpr( has_apply0_bool ) {
  153|  85.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  85.9k|            }
  155|  85.9k|         }
  156|  6.02M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 85.9k, False: 5.93M]
  ------------------
  157|  85.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  85.9k|         }
  159|  5.93M|         else {
  160|  5.93M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.93M|         }
  162|  6.02M|         (void)m( result );
  163|  6.02M|         return result;
  164|  6.02M|      }
  165|  6.02M|   }
_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|  6.02M|      {
   73|  6.02M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.02M|         else {
   84|  6.02M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.02M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.02M|      }
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|  6.02M|      {
   59|  6.02M|         return Rule::match( in );
   60|  6.02M|      }
_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|  85.9k|   {
  104|  85.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  85.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|  85.9k|   }
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|  85.9k|      {
   44|  85.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  85.9k|      }
_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|  85.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  85.9k|      else {
  108|  85.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.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|  85.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|  85.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|  85.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|  85.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|  85.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|  85.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.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|  85.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.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|  85.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  85.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 85.9k, False: 77]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  85.9k|            else if constexpr( has_apply0_bool ) {
  153|  85.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  85.9k|            }
  155|  85.9k|         }
  156|  85.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 85.9k, False: 77]
  ------------------
  157|  85.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  85.9k|         }
  159|     77|         else {
  160|     77|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     77|         }
  162|  85.9k|         (void)m( result );
  163|  85.9k|         return result;
  164|  85.9k|      }
  165|  85.9k|   }
_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|  85.9k|      {
   73|  85.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|  85.9k|         else {
   84|  85.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.9k|      }
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|  85.9k|      {
   44|  85.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  85.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  85.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  85.9k|      else {
  108|  85.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.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|  85.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|  85.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|  85.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|  85.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|  85.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|  85.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.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|  85.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.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|  85.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  85.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.8k, False: 48.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|  37.8k|            else if constexpr( has_apply0_bool ) {
  153|  37.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.8k|            }
  155|  37.8k|         }
  156|  85.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.8k, False: 48.1k]
  ------------------
  157|  37.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.8k|         }
  159|  48.1k|         else {
  160|  48.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  48.1k|         }
  162|  85.9k|         (void)m( result );
  163|  85.9k|         return result;
  164|  85.9k|      }
  165|  85.9k|   }
_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|  85.9k|      {
   73|  85.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|  85.9k|         else {
   84|  85.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.9k|      }
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|  85.9k|      {
   44|  85.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  85.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  85.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  85.9k|      else {
  108|  85.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  85.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  85.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|  85.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|  85.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|  85.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|  85.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|  85.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|  85.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  85.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  85.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  85.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|  85.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  85.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  85.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|  85.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  85.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  85.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  85.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  85.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.8k, False: 48.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|  37.8k|            else if constexpr( has_apply0_bool ) {
  153|  37.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.8k|            }
  155|  37.8k|         }
  156|  85.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.8k, False: 48.1k]
  ------------------
  157|  37.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.8k|         }
  159|  48.1k|         else {
  160|  48.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  48.1k|         }
  162|  85.9k|         (void)m( result );
  163|  85.9k|         return result;
  164|  85.9k|      }
  165|  85.9k|   }
_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|  85.9k|      {
   73|  85.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|  85.9k|         else {
   84|  85.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  85.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  85.9k|      }
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|  85.9k|      {
   59|  85.9k|         return Rule::match( in );
   60|  85.9k|      }
_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|  37.8k|   {
  104|  37.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  37.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|  37.8k|   }
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|  37.8k|      {
   44|  37.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.8k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  37.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.8k|      else {
  108|  37.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  37.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  37.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  37.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  37.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  37.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.8k, 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|  37.8k|            else if constexpr( has_apply0_bool ) {
  153|  37.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.8k|            }
  155|  37.8k|         }
  156|  37.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.8k, False: 26]
  ------------------
  157|  37.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.8k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  37.8k|         (void)m( result );
  163|  37.8k|         return result;
  164|  37.8k|      }
  165|  37.8k|   }
_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|  37.8k|      {
   73|  37.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  37.8k|         else {
   84|  37.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  37.8k|      {
   44|  37.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  75.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.6k|      else {
  108|  75.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.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|  75.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|  75.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|  75.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|  75.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|  75.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|  75.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.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|  75.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.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|  75.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 75.6k, 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|  75.6k|            else if constexpr( has_apply0_bool ) {
  153|  75.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  75.6k|            }
  155|  75.6k|         }
  156|  75.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 75.6k, False: 26]
  ------------------
  157|  75.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  75.6k|         }
  159|     26|         else {
  160|     26|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     26|         }
  162|  75.6k|         (void)m( result );
  163|  75.6k|         return result;
  164|  75.6k|      }
  165|  75.6k|   }
_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|  75.6k|      {
   73|  75.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|  75.6k|         else {
   84|  75.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.6k|      }
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|  75.6k|      {
   59|  75.6k|         return Rule::match( in );
   60|  75.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.1k|      else {
  108|  48.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.7k, False: 33.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|  14.7k|            else if constexpr( has_apply0_bool ) {
  153|  14.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.7k|            }
  155|  14.7k|         }
  156|  48.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.7k, False: 33.3k]
  ------------------
  157|  14.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.7k|         }
  159|  33.3k|         else {
  160|  33.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  33.3k|         }
  162|  48.1k|         (void)m( result );
  163|  48.1k|         return result;
  164|  48.1k|      }
  165|  48.1k|   }
_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|  48.1k|      {
   73|  48.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.1k|         else {
   84|  48.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  48.1k|      {
   44|  48.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  68.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  68.6k|      else {
  108|  68.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  68.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  68.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|  68.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|  68.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|  68.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|  68.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|  68.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|  68.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  68.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  68.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  68.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|  68.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  68.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  68.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|  68.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  68.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  68.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  68.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  68.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.9k, False: 43.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|  24.9k|            else if constexpr( has_apply0_bool ) {
  153|  24.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.9k|            }
  155|  24.9k|         }
  156|  68.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.9k, False: 43.6k]
  ------------------
  157|  24.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.9k|         }
  159|  43.6k|         else {
  160|  43.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.6k|         }
  162|  68.6k|         (void)m( result );
  163|  68.6k|         return result;
  164|  68.6k|      }
  165|  68.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  68.6k|      {
   73|  68.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|  68.6k|         else {
   84|  68.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  68.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  68.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  68.6k|      {
   59|  68.6k|         return Rule::match( in );
   60|  68.6k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  14.7k|   {
  104|  14.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  14.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|  14.7k|   }
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|  14.7k|      {
   44|  14.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.7k|      }
_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|  14.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.7k|      else {
  108|  14.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.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|  14.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|  14.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|  14.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|  14.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|  14.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|  14.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.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|  14.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.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|  14.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.7k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  14.7k|            else if constexpr( has_apply0_bool ) {
  153|  14.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.7k|            }
  155|  14.7k|         }
  156|  14.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.7k, False: 0]
  ------------------
  157|  14.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.7k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  14.7k|         (void)m( result );
  163|  14.7k|         return result;
  164|  14.7k|      }
  165|  14.7k|   }
_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|  14.7k|      {
   73|  14.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|  14.7k|         else {
   84|  14.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.7k|      }
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|  14.7k|      {
   44|  14.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  33.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.3k|      else {
  108|  33.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.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|  33.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|  33.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|  33.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|  33.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.6k, 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|  32.6k|            else if constexpr( has_apply0_bool ) {
  153|  32.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.6k|            }
  155|  32.6k|         }
  156|  33.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.6k, False: 696]
  ------------------
  157|  32.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.6k|         }
  159|    696|         else {
  160|    696|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    696|         }
  162|  33.3k|         (void)m( result );
  163|  33.3k|         return result;
  164|  33.3k|      }
  165|  33.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  33.3k|      {
   73|  33.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|  33.3k|         else {
   84|  33.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  33.3k|      {
   59|  33.3k|         return Rule::match( in );
   60|  33.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_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: 645, 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|    645|            else if constexpr( has_apply0_bool ) {
  153|    645|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    645|            }
  155|    645|         }
  156|    696|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 645, False: 51]
  ------------------
  157|    645|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    645|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|    696|         (void)m( result );
  163|    696|         return result;
  164|    696|      }
  165|    696|   }
_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|    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_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_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_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.93M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.93M|      else {
  108|  5.93M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.93M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.93M|         constexpr bool has_apply_void = enable_action && internal::has_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.93M|         constexpr bool has_apply_bool = enable_action && internal::has_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.93M|         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.93M|         constexpr bool has_apply0_void = enable_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.93M|         constexpr bool has_apply0_bool = enable_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.93M|         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.93M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.93M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.93M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.93M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.93M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.93M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.93M|         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.93M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.93M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.93M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.93M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.93M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.93M, False: 183]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.93M|            else if constexpr( has_apply0_bool ) {
  153|  5.93M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.93M|            }
  155|  5.93M|         }
  156|  5.93M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.93M, False: 183]
  ------------------
  157|  5.93M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.93M|         }
  159|    183|         else {
  160|    183|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    183|         }
  162|  5.93M|         (void)m( result );
  163|  5.93M|         return result;
  164|  5.93M|      }
  165|  5.93M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.93M|      {
   73|  5.93M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.93M|         else {
   84|  5.93M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.93M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.93M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.93M|      {
   59|  5.93M|         return Rule::match( in );
   60|  5.93M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  33.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.8k|      else {
  108|  33.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.08k, False: 30.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.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  33.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 30.7k]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|  30.7k|         else {
  160|  30.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.7k|         }
  162|  33.8k|         (void)m( result );
  163|  33.8k|         return result;
  164|  33.8k|      }
  165|  33.8k|   }
_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|  33.8k|      {
   73|  33.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.8k|         else {
   84|  33.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  33.8k|      {
   44|  33.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.8k|      }
_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|  33.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.8k|      else {
  108|  33.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.08k, False: 30.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.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  33.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 30.7k]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|  30.7k|         else {
  160|  30.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.7k|         }
  162|  33.8k|         (void)m( result );
  163|  33.8k|         return result;
  164|  33.8k|      }
  165|  33.8k|   }
_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|  33.8k|      {
   73|  33.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.8k|         else {
   84|  33.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  33.8k|      {
   44|  33.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  33.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.8k|      else {
  108|  33.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  33.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 33.8k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.8k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  33.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 33.8k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.57k, False: 30.2k]
  ------------------
  143|  3.57k|            if constexpr( has_apply_void ) {
  144|  3.57k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.57k|         }
  156|  33.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.57k, False: 30.2k]
  ------------------
  157|  3.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.57k|         }
  159|  30.2k|         else {
  160|  30.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  30.2k|         }
  162|  33.8k|         (void)m( result );
  163|  33.8k|         return result;
  164|  33.8k|      }
  165|  33.8k|   }
_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|  33.8k|      {
   73|  33.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.8k|         else {
   84|  33.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  33.8k|      {
   59|  33.8k|         return Rule::match( in );
   60|  33.8k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.34k|      else {
  108|  9.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.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|  9.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|  9.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|  9.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|  9.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|  9.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|  9.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.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|  9.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.56k, 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|  7.56k|            else if constexpr( has_apply0_bool ) {
  153|  7.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.56k|            }
  155|  7.56k|         }
  156|  9.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.56k, False: 1.77k]
  ------------------
  157|  7.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.56k|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  9.34k|         (void)m( result );
  163|  9.34k|         return result;
  164|  9.34k|      }
  165|  9.34k|   }
_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|  9.34k|      {
   73|  9.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|  9.34k|         else {
   84|  9.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.34k|      }
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|  9.34k|      {
   44|  9.34k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.34k|      else {
  108|  9.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.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|  9.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|  9.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|  9.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|  9.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|  9.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|  9.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.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|  9.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.56k, 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|  7.56k|            else if constexpr( has_apply0_bool ) {
  153|  7.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.56k|            }
  155|  7.56k|         }
  156|  9.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.56k, False: 1.77k]
  ------------------
  157|  7.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.56k|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  9.34k|         (void)m( result );
  163|  9.34k|         return result;
  164|  9.34k|      }
  165|  9.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.34k|      {
   73|  9.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|  9.34k|         else {
   84|  9.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.34k|      }
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|  9.34k|      {
   59|  9.34k|         return Rule::match( in );
   60|  9.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.6k|      else {
  108|  16.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.98k, 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|  4.98k|            else if constexpr( has_apply0_bool ) {
  153|  4.98k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.98k|            }
  155|  4.98k|         }
  156|  16.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.98k, False: 11.6k]
  ------------------
  157|  4.98k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.98k|         }
  159|  11.6k|         else {
  160|  11.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.6k|         }
  162|  16.6k|         (void)m( result );
  163|  16.6k|         return result;
  164|  16.6k|      }
  165|  16.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  16.6k|      {
   73|  16.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|  16.6k|         else {
   84|  16.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.6k|      {
   59|  16.6k|         return Rule::match( in );
   60|  16.6k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.08k, False: 466]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.08k|            else if constexpr( has_apply0_bool ) {
  153|  3.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.08k|            }
  155|  3.08k|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 466]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|    466|         else {
  160|    466|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    466|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.55k|      {
   44|  3.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.94k, 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.94k|            else if constexpr( has_apply0_bool ) {
  153|  1.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.94k|            }
  155|  1.94k|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.94k, False: 1.61k]
  ------------------
  157|  1.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.94k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.55k|      {
   44|  3.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.55k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.55k, 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.55k|            else if constexpr( has_apply0_bool ) {
  153|  3.55k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.55k|            }
  155|  3.55k|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.55k, False: 0]
  ------------------
  157|  3.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.55k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.55k|      {
   44|  3.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.55k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|  3.55k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.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|  3.55k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.55k|      {
   44|  3.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.55k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.55k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.55k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.55k, False: 1.99k]
  ------------------
  143|  1.55k|            if constexpr( has_apply_void ) {
  144|  1.55k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.55k|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.55k, False: 1.99k]
  ------------------
  157|  1.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.55k|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.55k|      {
   44|  3.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 236, False: 3.31k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    236|            else if constexpr( has_apply0_bool ) {
  153|    236|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    236|            }
  155|    236|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 236, False: 3.31k]
  ------------------
  157|    236|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    236|         }
  159|  3.31k|         else {
  160|  3.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.31k|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.55k|      {
   59|  3.55k|         return Rule::match( in );
   60|  3.55k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.31k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.31k|      else {
  108|  3.31k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.31k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.31k|         constexpr bool has_apply_void = enable_action && internal::has_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.31k|         constexpr bool has_apply_bool = enable_action && internal::has_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.31k|         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.31k|         constexpr bool has_apply0_void = enable_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.31k|         constexpr bool has_apply0_bool = enable_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.31k|         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.31k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.31k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.31k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.31k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.31k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.31k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.31k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.31k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.31k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.31k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.31k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.31k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, False: 3.11k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  3.31k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 3.11k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  3.11k|         else {
  160|  3.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.11k|         }
  162|  3.31k|         (void)m( result );
  163|  3.31k|         return result;
  164|  3.31k|      }
  165|  3.31k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.31k|      {
   73|  3.31k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.31k|         else {
   84|  3.31k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.31k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.31k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.31k|      {
   59|  3.31k|         return Rule::match( in );
   60|  3.31k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.11k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.11k|      else {
  108|  3.11k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.11k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.11k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.11k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.11k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.11k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.11k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.11k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.11k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.11k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.11k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.11k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.11k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.11k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.11k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.11k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.11k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.11k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.11k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.11k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 205, False: 2.91k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    205|            else if constexpr( has_apply0_bool ) {
  153|    205|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    205|            }
  155|    205|         }
  156|  3.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 205, False: 2.91k]
  ------------------
  157|    205|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    205|         }
  159|  2.91k|         else {
  160|  2.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.91k|         }
  162|  3.11k|         (void)m( result );
  163|  3.11k|         return result;
  164|  3.11k|      }
  165|  3.11k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.11k|      {
   73|  3.11k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.11k|         else {
   84|  3.11k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.11k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.11k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.11k|      {
   59|  3.11k|         return Rule::match( in );
   60|  3.11k|      }
_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.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.91k|      else {
  108|  2.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 332, 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|    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.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 2.57k]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|  2.57k|         else {
  160|  2.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.57k|         }
  162|  2.91k|         (void)m( result );
  163|  2.91k|         return result;
  164|  2.91k|      }
  165|  2.91k|   }
_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.91k|      {
   73|  2.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.91k|         else {
   84|  2.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.91k|      {
   59|  2.91k|         return Rule::match( in );
   60|  2.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.57k|      else {
  108|  2.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.57k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.57k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.57k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.57k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.57k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.57k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.57k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 383, False: 2.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    383|            else if constexpr( has_apply0_bool ) {
  153|    383|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    383|            }
  155|    383|         }
  156|  2.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 383, False: 2.19k]
  ------------------
  157|    383|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    383|         }
  159|  2.19k|         else {
  160|  2.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.19k|         }
  162|  2.57k|         (void)m( result );
  163|  2.57k|         return result;
  164|  2.57k|      }
  165|  2.57k|   }
_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.57k|      {
   73|  2.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.57k|         else {
   84|  2.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.57k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.57k|      {
   59|  2.57k|         return Rule::match( in );
   60|  2.57k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.19k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.19k|      else {
  108|  2.19k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.19k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.19k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.19k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.19k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.19k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.19k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.19k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.19k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.19k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.19k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.19k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.19k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.19k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.19k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.19k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.19k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.19k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.19k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.19k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 201, False: 1.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|    201|            else if constexpr( has_apply0_bool ) {
  153|    201|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    201|            }
  155|    201|         }
  156|  2.19k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 201, False: 1.99k]
  ------------------
  157|    201|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    201|         }
  159|  1.99k|         else {
  160|  1.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.99k|         }
  162|  2.19k|         (void)m( result );
  163|  2.19k|         return result;
  164|  2.19k|      }
  165|  2.19k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.19k|      {
   73|  2.19k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.19k|         else {
   84|  2.19k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.19k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.19k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.19k|      {
   59|  2.19k|         return Rule::match( in );
   60|  2.19k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.55k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.55k|      else {
  108|  3.55k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.55k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.55k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.55k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.55k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.55k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.55k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.55k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.55k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.55k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.55k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.55k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.08k, False: 1.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.08k|            else if constexpr( has_apply0_bool ) {
  153|  2.08k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.08k|            }
  155|  2.08k|         }
  156|  3.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.08k, False: 1.46k]
  ------------------
  157|  2.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.08k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|  3.55k|         (void)m( result );
  163|  3.55k|         return result;
  164|  3.55k|      }
  165|  3.55k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.55k|      {
   73|  3.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|  3.55k|         else {
   84|  3.55k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.55k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.55k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.55k|      {
   59|  3.55k|         return Rule::match( in );
   60|  3.55k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.12k|      else {
  108|  4.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.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|  4.12k|            else if constexpr( has_apply0_bool ) {
  153|  4.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.12k|            }
  155|  4.12k|         }
  156|  4.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.12k, False: 0]
  ------------------
  157|  4.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.12k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.12k|         (void)m( result );
  163|  4.12k|         return result;
  164|  4.12k|      }
  165|  4.12k|   }
_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|  4.12k|      {
   73|  4.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|  4.12k|         else {
   84|  4.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.12k|      }
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|  4.12k|      {
   44|  4.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.12k|      }
_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|  2.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.08k|      else {
  108|  2.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.08k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.08k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.08k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.08k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.08k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.08k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.08k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.08k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.04k, False: 43]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.04k|            else if constexpr( has_apply0_bool ) {
  153|  2.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.04k|            }
  155|  2.04k|         }
  156|  2.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.04k, False: 43]
  ------------------
  157|  2.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.04k|         }
  159|     43|         else {
  160|     43|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     43|         }
  162|  2.08k|         (void)m( result );
  163|  2.08k|         return result;
  164|  2.08k|      }
  165|  2.08k|   }
_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|  2.08k|      {
   73|  2.08k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.08k|         else {
   84|  2.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.08k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  2.08k|      {
   44|  2.08k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.08k|      }
_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|  2.05k|   {
  104|  2.05k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.05k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.05k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.05k|      {
   44|  2.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.05k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.21k|   {
  104|  4.21k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.21k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.21k|      {
   44|  4.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.21k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.04k|      else {
  108|  2.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.04k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.94k, 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|  1.94k|            else if constexpr( has_apply0_bool ) {
  153|  1.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.94k|            }
  155|  1.94k|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.94k, False: 103]
  ------------------
  157|  1.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.94k|         }
  159|    103|         else {
  160|    103|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    103|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.04k|         else {
   84|  2.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.04k|      {
   59|  2.04k|         return Rule::match( in );
   60|  2.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.16k|      else {
  108|  6.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.16k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.16k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 787]
  ------------------
  143|  5.37k|            if constexpr( has_apply_void ) {
  144|  5.37k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.37k|         }
  156|  6.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.36k, False: 804]
  ------------------
  157|  5.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.36k|         }
  159|    804|         else {
  160|    804|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    804|         }
  162|  6.16k|         (void)m( result );
  163|  6.16k|         return result;
  164|  6.16k|      }
  165|  6.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.16k|      {
   73|  6.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.16k|         else {
   84|  6.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.16k|      {
   44|  6.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.16k|      else {
  108|  6.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.58k, False: 580]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.58k|            else if constexpr( has_apply0_bool ) {
  153|  5.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.58k|            }
  155|  5.58k|         }
  156|  6.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.58k, False: 580]
  ------------------
  157|  5.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.58k|         }
  159|    580|         else {
  160|    580|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    580|         }
  162|  6.16k|         (void)m( result );
  163|  6.16k|         return result;
  164|  6.16k|      }
  165|  6.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.16k|      {
   73|  6.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.16k|         else {
   84|  6.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.16k|      {
   59|  6.16k|         return Rule::match( in );
   60|  6.16k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.58k|   {
  104|  5.58k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.58k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.58k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.58k|      {
   44|  5.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.58k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.58k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.58k|      else {
  108|  5.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.58k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.58k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.58k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.58k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, 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|  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|  5.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 207]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|    207|         else {
  160|    207|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    207|         }
  162|  5.58k|         (void)m( result );
  163|  5.58k|         return result;
  164|  5.58k|      }
  165|  5.58k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.58k|      {
   73|  5.58k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.58k|         else {
   84|  5.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.58k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.58k|      {
   44|  5.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.58k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.38M|      else {
  108|  2.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.38M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.38M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.38M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.38M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.38M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.38M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.38M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 2.38M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.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|  2.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 2.38M]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|  2.38M|         else {
  160|  2.38M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.38M|         }
  162|  2.38M|         (void)m( result );
  163|  2.38M|         return result;
  164|  2.38M|      }
  165|  2.38M|   }
_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.38M|      {
   73|  2.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.38M|         else {
   84|  2.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.38M|      }
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.38M|      {
   59|  2.38M|         return Rule::match( in );
   60|  2.38M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.38M|      else {
  108|  2.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.38M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.38M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.38M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.38M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.38M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.38M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.38M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.38M, 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|  2.38M|            else if constexpr( has_apply0_bool ) {
  153|  2.38M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.38M|            }
  155|  2.38M|         }
  156|  2.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.38M, False: 207]
  ------------------
  157|  2.38M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.38M|         }
  159|    207|         else {
  160|    207|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    207|         }
  162|  2.38M|         (void)m( result );
  163|  2.38M|         return result;
  164|  2.38M|      }
  165|  2.38M|   }
_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.38M|      {
   73|  2.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.38M|         else {
   84|  2.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.38M|      }
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.38M|      {
   44|  2.38M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.38M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.38M|      else {
  108|  2.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.38M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.38M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.38M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.38M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.38M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.38M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.38M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.31k, False: 2.37M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.31k|            else if constexpr( has_apply0_bool ) {
  153|  5.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.31k|            }
  155|  5.31k|         }
  156|  2.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.31k, False: 2.37M]
  ------------------
  157|  5.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.31k|         }
  159|  2.37M|         else {
  160|  2.37M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.37M|         }
  162|  2.38M|         (void)m( result );
  163|  2.38M|         return result;
  164|  2.38M|      }
  165|  2.38M|   }
_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.38M|      {
   73|  2.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.38M|         else {
   84|  2.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.38M|      }
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.38M|      {
   44|  2.38M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.38M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.38M|      else {
  108|  2.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.38M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.38M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.38M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.38M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.38M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.38M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.38M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.35k, False: 2.37M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.35k|            else if constexpr( has_apply0_bool ) {
  153|  5.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.35k|            }
  155|  5.35k|         }
  156|  2.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.35k, False: 2.37M]
  ------------------
  157|  5.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.35k|         }
  159|  2.37M|         else {
  160|  2.37M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.37M|         }
  162|  2.38M|         (void)m( result );
  163|  2.38M|         return result;
  164|  2.38M|      }
  165|  2.38M|   }
_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.38M|      {
   73|  2.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.38M|         else {
   84|  2.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.38M|      }
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.38M|      {
   59|  2.38M|         return Rule::match( in );
   60|  2.38M|      }
_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.35k|   {
  104|  5.35k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.35k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.35k|   }
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.35k|      {
   44|  5.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.35k|      }
_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.35k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.35k|      else {
  108|  5.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.35k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.31k, False: 45]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.31k|            else if constexpr( has_apply0_bool ) {
  153|  5.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.31k|            }
  155|  5.31k|         }
  156|  5.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.31k, False: 45]
  ------------------
  157|  5.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.31k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  5.35k|         (void)m( result );
  163|  5.35k|         return result;
  164|  5.35k|      }
  165|  5.35k|   }
_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.35k|      {
   73|  5.35k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.35k|         else {
   84|  5.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.35k|      }
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.35k|      {
   44|  5.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.35k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.35k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.35k|      else {
  108|  5.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.35k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 3.91k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.44k|            else if constexpr( has_apply0_bool ) {
  153|  1.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.44k|            }
  155|  1.44k|         }
  156|  5.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 3.91k]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|  3.91k|         else {
  160|  3.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.91k|         }
  162|  5.35k|         (void)m( result );
  163|  5.35k|         return result;
  164|  5.35k|      }
  165|  5.35k|   }
_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.35k|      {
   73|  5.35k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.35k|         else {
   84|  5.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.35k|      }
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.35k|      {
   44|  5.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.35k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.35k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.35k|      else {
  108|  5.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.35k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.46k, False: 3.89k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.46k|            else if constexpr( has_apply0_bool ) {
  153|  1.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.46k|            }
  155|  1.46k|         }
  156|  5.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.46k, False: 3.89k]
  ------------------
  157|  1.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.46k|         }
  159|  3.89k|         else {
  160|  3.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.89k|         }
  162|  5.35k|         (void)m( result );
  163|  5.35k|         return result;
  164|  5.35k|      }
  165|  5.35k|   }
_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.35k|      {
   73|  5.35k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.35k|         else {
   84|  5.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.35k|      }
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.35k|      {
   59|  5.35k|         return Rule::match( in );
   60|  5.35k|      }
_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.46k|   {
  104|  1.46k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.46k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.46k|   }
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.46k|      {
   44|  1.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.46k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.46k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.46k|      else {
  108|  1.46k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.46k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.46k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.46k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.46k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.46k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.46k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.46k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.46k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.46k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.46k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.46k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.46k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.46k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.46k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.46k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.46k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.46k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.46k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.46k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.44k|            else if constexpr( has_apply0_bool ) {
  153|  1.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.44k|            }
  155|  1.44k|         }
  156|  1.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 21]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  1.46k|         (void)m( result );
  163|  1.46k|         return result;
  164|  1.46k|      }
  165|  1.46k|   }
_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.46k|      {
   73|  1.46k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.46k|         else {
   84|  1.46k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.46k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.46k|      }
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.46k|      {
   44|  1.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.46k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  2.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.91k|      else {
  108|  2.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.89k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.89k|            else if constexpr( has_apply0_bool ) {
  153|  2.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.89k|            }
  155|  2.89k|         }
  156|  2.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.89k, False: 21]
  ------------------
  157|  2.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.89k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  2.91k|         (void)m( result );
  163|  2.91k|         return result;
  164|  2.91k|      }
  165|  2.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  2.91k|      {
   73|  2.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.91k|         else {
   84|  2.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.91k|      {
   59|  2.91k|         return Rule::match( in );
   60|  2.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.89k|      else {
  108|  3.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.89k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.00k, False: 2.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.00k|            else if constexpr( has_apply0_bool ) {
  153|  1.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.00k|            }
  155|  1.00k|         }
  156|  3.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.00k, False: 2.88k]
  ------------------
  157|  1.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.00k|         }
  159|  2.88k|         else {
  160|  2.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.88k|         }
  162|  3.89k|         (void)m( result );
  163|  3.89k|         return result;
  164|  3.89k|      }
  165|  3.89k|   }
_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.89k|      {
   73|  3.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.89k|         else {
   84|  3.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.89k|      {
   44|  3.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.24k|      else {
  108|  5.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.64k, 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|  1.64k|            else if constexpr( has_apply0_bool ) {
  153|  1.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.64k|            }
  155|  1.64k|         }
  156|  5.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.64k, False: 3.59k]
  ------------------
  157|  1.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.64k|         }
  159|  3.59k|         else {
  160|  3.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.59k|         }
  162|  5.24k|         (void)m( result );
  163|  5.24k|         return result;
  164|  5.24k|      }
  165|  5.24k|   }
_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.24k|      {
   73|  5.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|  5.24k|         else {
   84|  5.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.24k|      }
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.24k|      {
   59|  5.24k|         return Rule::match( in );
   60|  5.24k|      }
_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.00k|   {
  104|  1.00k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.00k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.00k|   }
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.00k|      {
   44|  1.00k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.00k|      }
_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.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.00k|      else {
  108|  1.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.00k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.00k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.00k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.00k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.00k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.00k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.00k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.00k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.00k, 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.00k|            else if constexpr( has_apply0_bool ) {
  153|  1.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.00k|            }
  155|  1.00k|         }
  156|  1.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.00k, False: 0]
  ------------------
  157|  1.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.00k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  1.00k|         (void)m( result );
  163|  1.00k|         return result;
  164|  1.00k|      }
  165|  1.00k|   }
_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.00k|      {
   73|  1.00k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.00k|         else {
   84|  1.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.00k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.00k|      {
   44|  1.00k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.00k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88k|      else {
  108|  2.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.64k, 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|  2.64k|            else if constexpr( has_apply0_bool ) {
  153|  2.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.64k|            }
  155|  2.64k|         }
  156|  2.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.64k, False: 245]
  ------------------
  157|  2.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.64k|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  2.88k|         (void)m( result );
  163|  2.88k|         return result;
  164|  2.88k|      }
  165|  2.88k|   }
_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.88k|      {
   73|  2.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.88k|         else {
   84|  2.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.88k|      {
   59|  2.88k|         return Rule::match( in );
   60|  2.88k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    245|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    245|      else {
  108|    245|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    245|         using iterator_t = typename ParseInput::iterator_t;
  111|    245|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    245|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    245|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    245|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    245|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    245|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    245|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    245|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    245|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    245|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    245|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    245|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    245|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    245|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    245|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    245|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    245|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    245|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 221, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    221|            else if constexpr( has_apply0_bool ) {
  153|    221|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    221|            }
  155|    221|         }
  156|    245|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 221, False: 24]
  ------------------
  157|    221|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    221|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|    245|         (void)m( result );
  163|    245|         return result;
  164|    245|      }
  165|    245|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    245|      {
   73|    245|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    245|         else {
   84|    245|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    245|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    245|      }
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|    245|      {
   59|    245|         return Rule::match( in );
   60|    245|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.37M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.37M|      else {
  108|  2.37M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.37M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.37M|         constexpr bool has_apply_void = enable_action && internal::has_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.37M|         constexpr bool has_apply_bool = enable_action && internal::has_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.37M|         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.37M|         constexpr bool has_apply0_void = enable_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.37M|         constexpr bool has_apply0_bool = enable_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.37M|         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.37M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.37M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.37M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.37M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.37M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.37M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.37M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.37M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.37M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.37M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.37M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.37M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.37M, 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.37M|            else if constexpr( has_apply0_bool ) {
  153|  2.37M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.37M|            }
  155|  2.37M|         }
  156|  2.37M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.37M, False: 162]
  ------------------
  157|  2.37M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.37M|         }
  159|    162|         else {
  160|    162|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    162|         }
  162|  2.37M|         (void)m( result );
  163|  2.37M|         return result;
  164|  2.37M|      }
  165|  2.37M|   }
_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.37M|      {
   73|  2.37M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.37M|         else {
   84|  2.37M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.37M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.37M|      }
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.37M|      {
   59|  2.37M|         return Rule::match( in );
   60|  2.37M|      }
_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|  30.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.4k|      else {
  108|  30.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  30.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 27.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.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|  30.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 27.0k]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|  27.0k|         else {
  160|  27.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.0k|         }
  162|  30.4k|         (void)m( result );
  163|  30.4k|         return result;
  164|  30.4k|      }
  165|  30.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.4k|      {
   73|  30.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.4k|         else {
   84|  30.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.4k|      {
   44|  30.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  30.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.4k|      else {
  108|  30.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  30.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 27.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.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|  30.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 27.0k]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|  27.0k|         else {
  160|  27.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.0k|         }
  162|  30.4k|         (void)m( result );
  163|  30.4k|         return result;
  164|  30.4k|      }
  165|  30.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_12str_via_portENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.4k|      {
   73|  30.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.4k|         else {
   84|  30.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.4k|      {
   44|  30.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  30.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.4k|      else {
  108|  30.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  30.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  30.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 30.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  30.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  30.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  30.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  30.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  30.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  30.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 30.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.12k, False: 26.3k]
  ------------------
  143|  4.12k|            if constexpr( has_apply_void ) {
  144|  4.12k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.12k|         }
  156|  30.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.12k, False: 26.3k]
  ------------------
  157|  4.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.12k|         }
  159|  26.3k|         else {
  160|  26.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  26.3k|         }
  162|  30.4k|         (void)m( result );
  163|  30.4k|         return result;
  164|  30.4k|      }
  165|  30.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  30.4k|      {
   73|  30.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  30.4k|         else {
   84|  30.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  30.4k|      {
   59|  30.4k|         return Rule::match( in );
   60|  30.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  11.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.2k|      else {
  108|  11.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.42k, False: 1.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.42k|            else if constexpr( has_apply0_bool ) {
  153|  9.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.42k|            }
  155|  9.42k|         }
  156|  11.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.42k, False: 1.81k]
  ------------------
  157|  9.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.42k|         }
  159|  1.81k|         else {
  160|  1.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.81k|         }
  162|  11.2k|         (void)m( result );
  163|  11.2k|         return result;
  164|  11.2k|      }
  165|  11.2k|   }
_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|  11.2k|      {
   73|  11.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|  11.2k|         else {
   84|  11.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.2k|      }
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|  11.2k|      {
   44|  11.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  11.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.2k|      else {
  108|  11.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.42k, False: 1.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.42k|            else if constexpr( has_apply0_bool ) {
  153|  9.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.42k|            }
  155|  9.42k|         }
  156|  11.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.42k, False: 1.81k]
  ------------------
  157|  9.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.42k|         }
  159|  1.81k|         else {
  160|  1.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.81k|         }
  162|  11.2k|         (void)m( result );
  163|  11.2k|         return result;
  164|  11.2k|      }
  165|  11.2k|   }
_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|  11.2k|      {
   73|  11.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|  11.2k|         else {
   84|  11.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.2k|      }
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|  11.2k|      {
   59|  11.2k|         return Rule::match( in );
   60|  11.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  21.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.5k|      else {
  108|  21.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  21.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  21.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  21.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  21.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  21.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  21.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  21.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  21.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.46k, False: 15.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|  6.46k|            else if constexpr( has_apply0_bool ) {
  153|  6.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.46k|            }
  155|  6.46k|         }
  156|  21.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.46k, False: 15.0k]
  ------------------
  157|  6.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.46k|         }
  159|  15.0k|         else {
  160|  15.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.0k|         }
  162|  21.5k|         (void)m( result );
  163|  21.5k|         return result;
  164|  21.5k|      }
  165|  21.5k|   }
_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|  21.5k|      {
   73|  21.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  21.5k|         else {
   84|  21.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  21.5k|      {
   59|  21.5k|         return Rule::match( in );
   60|  21.5k|      }
_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|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 683]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 683]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|    683|         else {
  160|    683|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    683|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_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|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.64k, False: 1.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.64k|            else if constexpr( has_apply0_bool ) {
  153|  2.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.64k|            }
  155|  2.64k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.64k, False: 1.46k]
  ------------------
  157|  2.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.64k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_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|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.10k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.10k|            else if constexpr( has_apply0_bool ) {
  153|  4.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.10k|            }
  155|  4.10k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.10k, False: 0]
  ------------------
  157|  4.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.10k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_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|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|  4.10k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.10k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.10k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_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|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.10k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.10k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.62k, False: 2.48k]
  ------------------
  143|  1.62k|            if constexpr( has_apply_void ) {
  144|  1.62k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.62k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.62k, False: 2.48k]
  ------------------
  157|  1.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.62k|         }
  159|  2.48k|         else {
  160|  2.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.48k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_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|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_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: 217, False: 3.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    217|            else if constexpr( has_apply0_bool ) {
  153|    217|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    217|            }
  155|    217|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 217, False: 3.88k]
  ------------------
  157|    217|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    217|         }
  159|  3.88k|         else {
  160|  3.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.88k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.10k|      {
   59|  4.10k|         return Rule::match( in );
   60|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.88k|      else {
  108|  3.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 223, False: 3.66k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 223, False: 3.66k]
  ------------------
  157|    223|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    223|         }
  159|  3.66k|         else {
  160|  3.66k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.66k|         }
  162|  3.88k|         (void)m( result );
  163|  3.88k|         return result;
  164|  3.88k|      }
  165|  3.88k|   }
_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.88k|      {
   73|  3.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.88k|         else {
   84|  3.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.88k|      {
   59|  3.88k|         return Rule::match( in );
   60|  3.88k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.66k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.66k|      else {
  108|  3.66k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.66k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.66k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.66k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.66k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.66k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.66k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.66k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.66k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.66k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.66k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.66k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.66k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.66k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.66k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.66k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.66k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.66k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.66k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.66k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 3.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  3.66k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.47k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.47k|         else {
  160|  3.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.47k|         }
  162|  3.66k|         (void)m( result );
  163|  3.66k|         return result;
  164|  3.66k|      }
  165|  3.66k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.66k|      {
   73|  3.66k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.66k|         else {
   84|  3.66k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.66k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.66k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.66k|      {
   59|  3.66k|         return Rule::match( in );
   60|  3.66k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.47k|      else {
  108|  3.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 362, False: 3.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|    362|            else if constexpr( has_apply0_bool ) {
  153|    362|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    362|            }
  155|    362|         }
  156|  3.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 362, False: 3.10k]
  ------------------
  157|    362|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    362|         }
  159|  3.10k|         else {
  160|  3.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.10k|         }
  162|  3.47k|         (void)m( result );
  163|  3.47k|         return result;
  164|  3.47k|      }
  165|  3.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.47k|      {
   73|  3.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.47k|         else {
   84|  3.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.47k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.47k|      {
   59|  3.47k|         return Rule::match( in );
   60|  3.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.10k|      else {
  108|  3.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 429, False: 2.68k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    429|            else if constexpr( has_apply0_bool ) {
  153|    429|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    429|            }
  155|    429|         }
  156|  3.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 429, False: 2.68k]
  ------------------
  157|    429|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    429|         }
  159|  2.68k|         else {
  160|  2.68k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.68k|         }
  162|  3.10k|         (void)m( result );
  163|  3.10k|         return result;
  164|  3.10k|      }
  165|  3.10k|   }
_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|  3.10k|      {
   73|  3.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|  3.10k|         else {
   84|  3.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.10k|      }
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|  3.10k|      {
   59|  3.10k|         return Rule::match( in );
   60|  3.10k|      }
_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.68k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.68k|      else {
  108|  2.68k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.68k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.68k|         constexpr bool has_apply_void = enable_action && internal::has_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.68k|         constexpr bool has_apply_bool = enable_action && internal::has_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.68k|         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.68k|         constexpr bool has_apply0_void = enable_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.68k|         constexpr bool has_apply0_bool = enable_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.68k|         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.68k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.68k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.68k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.68k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.68k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.68k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.68k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.68k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.68k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.68k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.68k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.68k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 2.48k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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.68k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.48k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.48k|         else {
  160|  2.48k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.48k|         }
  162|  2.68k|         (void)m( result );
  163|  2.68k|         return result;
  164|  2.68k|      }
  165|  2.68k|   }
_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.68k|      {
   73|  2.68k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.68k|         else {
   84|  2.68k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.68k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.68k|      }
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.68k|      {
   59|  2.68k|         return Rule::match( in );
   60|  2.68k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.85k, False: 1.24k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.85k|            else if constexpr( has_apply0_bool ) {
  153|  2.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.85k|            }
  155|  2.85k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.85k, False: 1.24k]
  ------------------
  157|  2.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.85k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_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|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.10k|      {
   59|  4.10k|         return Rule::match( in );
   60|  4.10k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 5.64k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.64k|            else if constexpr( has_apply0_bool ) {
  153|  5.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.64k|            }
  155|  5.64k|         }
  156|  5.64k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.64k, False: 0]
  ------------------
  157|  5.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.64k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.64k|         (void)m( result );
  163|  5.64k|         return result;
  164|  5.64k|      }
  165|  5.64k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.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_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.64k|      {
   44|  5.64k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.64k|      }
_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.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.85k|      else {
  108|  2.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.78k, 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.78k|            else if constexpr( has_apply0_bool ) {
  153|  2.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.78k|            }
  155|  2.78k|         }
  156|  2.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.78k, False: 75]
  ------------------
  157|  2.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.78k|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|  2.85k|         (void)m( result );
  163|  2.85k|         return result;
  164|  2.85k|      }
  165|  2.85k|   }
_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.85k|      {
   73|  2.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|  2.85k|         else {
   84|  2.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.85k|      }
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.85k|      {
   44|  2.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.85k|      }
_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.79k|   {
  104|  2.79k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.79k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.79k|   }
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.79k|      {
   44|  2.79k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.79k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.49k|   {
  104|  5.49k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.49k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.49k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.49k|      {
   44|  5.49k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.49k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.78k|      else {
  108|  2.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.78k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.78k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.78k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.78k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.64k, False: 138]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.64k|            else if constexpr( has_apply0_bool ) {
  153|  2.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.64k|            }
  155|  2.64k|         }
  156|  2.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.64k, False: 138]
  ------------------
  157|  2.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.64k|         }
  159|    138|         else {
  160|    138|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    138|         }
  162|  2.78k|         (void)m( result );
  163|  2.78k|         return result;
  164|  2.78k|      }
  165|  2.78k|   }
_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.78k|      {
   73|  2.78k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.78k|         else {
   84|  2.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.78k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.78k|      {
   59|  2.78k|         return Rule::match( in );
   60|  2.78k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.03k|      else {
  108|  8.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.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|  8.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.03k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.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|  8.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|  8.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|  8.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.03k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.32k, False: 1.71k]
  ------------------
  143|  6.32k|            if constexpr( has_apply_void ) {
  144|  6.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|  6.32k|         }
  156|  8.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.27k, False: 1.76k]
  ------------------
  157|  6.27k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.27k|         }
  159|  1.76k|         else {
  160|  1.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.76k|         }
  162|  8.03k|         (void)m( result );
  163|  8.03k|         return result;
  164|  8.03k|      }
  165|  8.03k|   }
_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|  8.03k|      {
   73|  8.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|  8.03k|         else {
   84|  8.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.03k|      }
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|  8.03k|      {
   44|  8.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.03k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.03k|      else {
  108|  8.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.61k, False: 1.42k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.61k|            else if constexpr( has_apply0_bool ) {
  153|  6.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.61k|            }
  155|  6.61k|         }
  156|  8.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.61k, False: 1.42k]
  ------------------
  157|  6.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.61k|         }
  159|  1.42k|         else {
  160|  1.42k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.42k|         }
  162|  8.03k|         (void)m( result );
  163|  8.03k|         return result;
  164|  8.03k|      }
  165|  8.03k|   }
_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|  8.03k|      {
   73|  8.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|  8.03k|         else {
   84|  8.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.03k|      }
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|  8.03k|      {
   59|  8.03k|         return Rule::match( in );
   60|  8.03k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.61k|   {
  104|  6.61k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.61k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.61k|      {
   44|  6.61k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.61k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.61k|      else {
  108|  6.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.61k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.32k, False: 285]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.32k|            else if constexpr( has_apply0_bool ) {
  153|  6.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.32k|            }
  155|  6.32k|         }
  156|  6.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.32k, False: 285]
  ------------------
  157|  6.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.32k|         }
  159|    285|         else {
  160|    285|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    285|         }
  162|  6.61k|         (void)m( result );
  163|  6.61k|         return result;
  164|  6.61k|      }
  165|  6.61k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.61k|      {
   73|  6.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.61k|         else {
   84|  6.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.61k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.61k|      {
   44|  6.61k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.61k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.11M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.11M|      else {
  108|  8.11M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.11M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.11M|         constexpr bool has_apply_void = enable_action && internal::has_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.11M|         constexpr bool has_apply_bool = enable_action && internal::has_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.11M|         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.11M|         constexpr bool has_apply0_void = enable_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.11M|         constexpr bool has_apply0_bool = enable_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.11M|         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.11M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.11M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.11M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.11M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.11M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.11M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.11M|         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.11M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.11M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.11M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.11M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.11M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.32k, False: 8.10M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.32k|            else if constexpr( has_apply0_bool ) {
  153|  6.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.32k|            }
  155|  6.32k|         }
  156|  8.11M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.32k, False: 8.10M]
  ------------------
  157|  6.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.32k|         }
  159|  8.10M|         else {
  160|  8.10M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.10M|         }
  162|  8.11M|         (void)m( result );
  163|  8.11M|         return result;
  164|  8.11M|      }
  165|  8.11M|   }
_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|  8.11M|      {
   73|  8.11M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.11M|         else {
   84|  8.11M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.11M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.11M|      }
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|  8.11M|      {
   59|  8.11M|         return Rule::match( in );
   60|  8.11M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.10M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.10M|      else {
  108|  8.10M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.10M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.10M|         constexpr bool has_apply_void = enable_action && internal::has_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.10M|         constexpr bool has_apply_bool = enable_action && internal::has_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.10M|         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.10M|         constexpr bool has_apply0_void = enable_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.10M|         constexpr bool has_apply0_bool = enable_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.10M|         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.10M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.10M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.10M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.10M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.10M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.10M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.10M|         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.10M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.10M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.10M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.10M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.10M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.10M, False: 285]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.10M|            else if constexpr( has_apply0_bool ) {
  153|  8.10M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.10M|            }
  155|  8.10M|         }
  156|  8.10M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.10M, False: 285]
  ------------------
  157|  8.10M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.10M|         }
  159|    285|         else {
  160|    285|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    285|         }
  162|  8.10M|         (void)m( result );
  163|  8.10M|         return result;
  164|  8.10M|      }
  165|  8.10M|   }
_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|  8.10M|      {
   73|  8.10M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.10M|         else {
   84|  8.10M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.10M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.10M|      }
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|  8.10M|      {
   44|  8.10M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.10M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.10M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.10M|      else {
  108|  8.10M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.10M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.10M|         constexpr bool has_apply_void = enable_action && internal::has_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.10M|         constexpr bool has_apply_bool = enable_action && internal::has_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.10M|         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.10M|         constexpr bool has_apply0_void = enable_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.10M|         constexpr bool has_apply0_bool = enable_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.10M|         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.10M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.10M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.10M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.10M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.10M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.10M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.10M|         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.10M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.10M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.10M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.10M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.10M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 106k, False: 8.00M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  8.10M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 106k, False: 8.00M]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|  8.00M|         else {
  160|  8.00M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.00M|         }
  162|  8.10M|         (void)m( result );
  163|  8.10M|         return result;
  164|  8.10M|      }
  165|  8.10M|   }
_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|  8.10M|      {
   73|  8.10M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.10M|         else {
   84|  8.10M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.10M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.10M|      }
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|  8.10M|      {
   44|  8.10M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.10M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.10M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.10M|      else {
  108|  8.10M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.10M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.10M|         constexpr bool has_apply_void = enable_action && internal::has_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.10M|         constexpr bool has_apply_bool = enable_action && internal::has_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.10M|         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.10M|         constexpr bool has_apply0_void = enable_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.10M|         constexpr bool has_apply0_bool = enable_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.10M|         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.10M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.10M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.10M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.10M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.10M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.10M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.10M|         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.10M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.10M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.10M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.10M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.10M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 106k, False: 8.00M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  8.10M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 106k, False: 8.00M]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|  8.00M|         else {
  160|  8.00M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.00M|         }
  162|  8.10M|         (void)m( result );
  163|  8.10M|         return result;
  164|  8.10M|      }
  165|  8.10M|   }
_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|  8.10M|      {
   73|  8.10M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.10M|         else {
   84|  8.10M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.10M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.10M|      }
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|  8.10M|      {
   59|  8.10M|         return Rule::match( in );
   60|  8.10M|      }
_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|   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_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|   106k|      {
   44|   106k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   106k|      }
_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|   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: 85]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   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: 85]
  ------------------
  157|   106k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   106k|         }
  159|     85|         else {
  160|     85|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     85|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_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|   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_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|   106k|      {
   44|   106k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   106k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   106k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   106k|      else {
  108|   106k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   106k|         using iterator_t = typename ParseInput::iterator_t;
  111|   106k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   106k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   106k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   106k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   106k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   106k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   106k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   106k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   106k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   106k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   106k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   106k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   106k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   106k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   106k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   106k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   106k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   106k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.0k, False: 62.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.0k|            else if constexpr( has_apply0_bool ) {
  153|  44.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.0k|            }
  155|  44.0k|         }
  156|   106k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.0k, False: 62.6k]
  ------------------
  157|  44.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.0k|         }
  159|  62.6k|         else {
  160|  62.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  62.6k|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_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|   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_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|   106k|      {
   44|   106k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   106k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 44.0k, False: 62.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.0k|            else if constexpr( has_apply0_bool ) {
  153|  44.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.0k|            }
  155|  44.0k|         }
  156|   106k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.0k, False: 62.6k]
  ------------------
  157|  44.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.0k|         }
  159|  62.6k|         else {
  160|  62.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  62.6k|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_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|   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_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   106k|      {
   59|   106k|         return Rule::match( in );
   60|   106k|      }
_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|  44.0k|   {
  104|  44.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  44.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|  44.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.0k|      {
   44|  44.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  44.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.0k|      else {
  108|  44.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.0k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.0k|            else if constexpr( has_apply0_bool ) {
  153|  44.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.0k|            }
  155|  44.0k|         }
  156|  44.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.0k, False: 21]
  ------------------
  157|  44.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.0k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  44.0k|         (void)m( result );
  163|  44.0k|         return result;
  164|  44.0k|      }
  165|  44.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  44.0k|      {
   73|  44.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|  44.0k|         else {
   84|  44.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.0k|      {
   44|  44.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_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: 88.0k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  88.0k|            else if constexpr( has_apply0_bool ) {
  153|  88.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  88.0k|            }
  155|  88.0k|         }
  156|  88.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 88.0k, False: 21]
  ------------------
  157|  88.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  88.0k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  88.0k|         (void)m( result );
  163|  88.0k|         return result;
  164|  88.0k|      }
  165|  88.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|  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_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  62.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  62.6k|      else {
  108|  62.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  62.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  62.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|  62.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|  62.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|  62.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|  62.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|  62.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|  62.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  62.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  62.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  62.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|  62.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  62.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  62.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|  62.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  62.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  62.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  62.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  62.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.8k, False: 31.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  30.8k|            else if constexpr( has_apply0_bool ) {
  153|  30.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.8k|            }
  155|  30.8k|         }
  156|  62.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.8k, False: 31.7k]
  ------------------
  157|  30.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.8k|         }
  159|  31.7k|         else {
  160|  31.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.7k|         }
  162|  62.6k|         (void)m( result );
  163|  62.6k|         return result;
  164|  62.6k|      }
  165|  62.6k|   }
_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|  62.6k|      {
   73|  62.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|  62.6k|         else {
   84|  62.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  62.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  62.6k|      }
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|  62.6k|      {
   44|  62.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  62.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   102k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   102k|      else {
  108|   102k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   102k|         using iterator_t = typename ParseInput::iterator_t;
  111|   102k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   102k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   102k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   102k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   102k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   102k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   102k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   102k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   102k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   102k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   102k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   102k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   102k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   102k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   102k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   102k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   102k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   102k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 46.8k, False: 55.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|  46.8k|            else if constexpr( has_apply0_bool ) {
  153|  46.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  46.8k|            }
  155|  46.8k|         }
  156|   102k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.8k, False: 55.9k]
  ------------------
  157|  46.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.8k|         }
  159|  55.9k|         else {
  160|  55.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  55.9k|         }
  162|   102k|         (void)m( result );
  163|   102k|         return result;
  164|   102k|      }
  165|   102k|   }
_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|   102k|      {
   73|   102k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   102k|         else {
   84|   102k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   102k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   102k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   102k|      {
   59|   102k|         return Rule::match( in );
   60|   102k|      }
_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|  30.8k|   {
  104|  30.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  30.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|  30.8k|   }
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|  30.8k|      {
   44|  30.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.8k|      }
_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|  30.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.8k|      else {
  108|  30.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.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|  30.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|  30.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|  30.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|  30.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|  30.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|  30.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.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|  30.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.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|  30.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.8k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  30.8k|            else if constexpr( has_apply0_bool ) {
  153|  30.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.8k|            }
  155|  30.8k|         }
  156|  30.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.8k, False: 0]
  ------------------
  157|  30.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.8k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  30.8k|         (void)m( result );
  163|  30.8k|         return result;
  164|  30.8k|      }
  165|  30.8k|   }
_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|  30.8k|      {
   73|  30.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|  30.8k|         else {
   84|  30.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.8k|      }
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|  30.8k|      {
   44|  30.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.7k|      else {
  108|  31.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  31.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|  31.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|  31.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|  31.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|  31.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|  31.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  31.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  31.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.2k, False: 524]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  31.2k|            else if constexpr( has_apply0_bool ) {
  153|  31.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.2k|            }
  155|  31.2k|         }
  156|  31.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.2k, False: 524]
  ------------------
  157|  31.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.2k|         }
  159|    524|         else {
  160|    524|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    524|         }
  162|  31.7k|         (void)m( result );
  163|  31.7k|         return result;
  164|  31.7k|      }
  165|  31.7k|   }
_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|  31.7k|      {
   73|  31.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|  31.7k|         else {
   84|  31.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.7k|      }
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|  31.7k|      {
   59|  31.7k|         return Rule::match( in );
   60|  31.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    524|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    524|      else {
  108|    524|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    524|         using iterator_t = typename ParseInput::iterator_t;
  111|    524|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    524|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    524|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    524|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    524|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    524|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    524|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    524|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    524|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    524|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    524|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    524|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    524|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    524|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    524|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    524|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    524|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    524|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 460, False: 64]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    460|            else if constexpr( has_apply0_bool ) {
  153|    460|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    460|            }
  155|    460|         }
  156|    524|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 460, False: 64]
  ------------------
  157|    460|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    460|         }
  159|     64|         else {
  160|     64|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     64|         }
  162|    524|         (void)m( result );
  163|    524|         return result;
  164|    524|      }
  165|    524|   }
_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|    524|      {
   73|    524|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    524|         else {
   84|    524|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    524|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    524|      }
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|    524|      {
   59|    524|         return Rule::match( in );
   60|    524|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.00M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.00M|      else {
  108|  8.00M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.00M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.00M|         constexpr bool has_apply_void = enable_action && internal::has_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.00M|         constexpr bool has_apply_bool = enable_action && internal::has_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.00M|         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.00M|         constexpr bool has_apply0_void = enable_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.00M|         constexpr bool has_apply0_bool = enable_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.00M|         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.00M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.00M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.00M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.00M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.00M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.00M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.00M|         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.00M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.00M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.00M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.00M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.00M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.00M, False: 200]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.00M|            else if constexpr( has_apply0_bool ) {
  153|  8.00M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.00M|            }
  155|  8.00M|         }
  156|  8.00M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.00M, False: 200]
  ------------------
  157|  8.00M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.00M|         }
  159|    200|         else {
  160|    200|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    200|         }
  162|  8.00M|         (void)m( result );
  163|  8.00M|         return result;
  164|  8.00M|      }
  165|  8.00M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.00M|      {
   73|  8.00M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.00M|         else {
   84|  8.00M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.00M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.00M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.00M|      {
   59|  8.00M|         return Rule::match( in );
   60|  8.00M|      }
_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|  26.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.7k|      else {
  108|  26.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.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|  26.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|  26.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|  26.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|  26.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.38k, 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|  4.38k|            else if constexpr( has_apply0_bool ) {
  153|  4.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.38k|            }
  155|  4.38k|         }
  156|  26.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.38k, False: 22.3k]
  ------------------
  157|  4.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.38k|         }
  159|  22.3k|         else {
  160|  22.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.3k|         }
  162|  26.7k|         (void)m( result );
  163|  26.7k|         return result;
  164|  26.7k|      }
  165|  26.7k|   }
_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|  26.7k|      {
   73|  26.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|  26.7k|         else {
   84|  26.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.7k|      }
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|  26.7k|      {
   44|  26.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.7k|      }
_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|  26.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.7k|      else {
  108|  26.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.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|  26.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|  26.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|  26.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|  26.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.38k, 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|  4.38k|            else if constexpr( has_apply0_bool ) {
  153|  4.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.38k|            }
  155|  4.38k|         }
  156|  26.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.38k, False: 22.3k]
  ------------------
  157|  4.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.38k|         }
  159|  22.3k|         else {
  160|  22.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.3k|         }
  162|  26.7k|         (void)m( result );
  163|  26.7k|         return result;
  164|  26.7k|      }
  165|  26.7k|   }
_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|  26.7k|      {
   73|  26.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|  26.7k|         else {
   84|  26.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.7k|      }
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|  26.7k|      {
   44|  26.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.7k|      }
_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|  26.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  26.7k|      else {
  108|  26.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  26.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  26.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|  26.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|  26.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 26.7k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  26.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|  26.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|  26.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|  26.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  26.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  26.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  26.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|  26.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  26.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  26.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|  26.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 26.7k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  26.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  26.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  26.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  26.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.84k, False: 21.8k]
  ------------------
  143|  4.84k|            if constexpr( has_apply_void ) {
  144|  4.84k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.84k|         }
  156|  26.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.84k, False: 21.8k]
  ------------------
  157|  4.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.84k|         }
  159|  21.8k|         else {
  160|  21.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  21.8k|         }
  162|  26.7k|         (void)m( result );
  163|  26.7k|         return result;
  164|  26.7k|      }
  165|  26.7k|   }
_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|  26.7k|      {
   73|  26.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|  26.7k|         else {
   84|  26.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  26.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  26.7k|      }
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|  26.7k|      {
   59|  26.7k|         return Rule::match( in );
   60|  26.7k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   167k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   167k|      else {
  108|   167k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   167k|         using iterator_t = typename ParseInput::iterator_t;
  111|   167k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   167k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   167k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   167k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   167k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   167k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   167k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   167k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   167k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   167k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   167k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   167k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   167k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   167k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   167k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   167k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   167k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   167k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 164k, 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|   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|   167k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 164k, False: 2.25k]
  ------------------
  157|   164k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   164k|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|   167k|         (void)m( result );
  163|   167k|         return result;
  164|   167k|      }
  165|   167k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   167k|      {
   73|   167k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   167k|         else {
   84|   167k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   167k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   167k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   167k|      {
   44|   167k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   167k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   167k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   167k|      else {
  108|   167k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   167k|         using iterator_t = typename ParseInput::iterator_t;
  111|   167k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   167k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   167k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   167k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   167k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   167k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   167k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   167k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   167k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   167k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   167k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   167k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   167k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   167k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   167k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   167k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   167k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   167k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 164k, 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|   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|   167k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 164k, False: 2.25k]
  ------------------
  157|   164k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   164k|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|   167k|         (void)m( result );
  163|   167k|         return result;
  164|   167k|      }
  165|   167k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   167k|      {
   73|   167k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   167k|         else {
   84|   167k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   167k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   167k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   167k|      {
   59|   167k|         return Rule::match( in );
   60|   167k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.53M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.53M|      else {
  108|  1.53M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.53M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.53M|         constexpr bool has_apply_void = enable_action && internal::has_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.53M|         constexpr bool has_apply_bool = enable_action && internal::has_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.53M|         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.53M|         constexpr bool has_apply0_void = enable_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.53M|         constexpr bool has_apply0_bool = enable_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.53M|         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.53M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.53M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.53M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.53M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.53M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.53M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.53M|         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.53M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.53M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.53M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.53M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.53M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.36M, 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.36M|            else if constexpr( has_apply0_bool ) {
  153|  1.36M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.36M|            }
  155|  1.36M|         }
  156|  1.53M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.36M, False: 172k]
  ------------------
  157|  1.36M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.36M|         }
  159|   172k|         else {
  160|   172k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   172k|         }
  162|  1.53M|         (void)m( result );
  163|  1.53M|         return result;
  164|  1.53M|      }
  165|  1.53M|   }
_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.53M|      {
   73|  1.53M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.53M|         else {
   84|  1.53M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.53M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.53M|      }
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.53M|      {
   59|  1.53M|         return Rule::match( in );
   60|  1.53M|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.38k, False: 446]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.38k|            else if constexpr( has_apply0_bool ) {
  153|  4.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.38k|            }
  155|  4.38k|         }
  156|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.38k, False: 446]
  ------------------
  157|  4.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.38k|         }
  159|    446|         else {
  160|    446|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    446|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.83k|      {
   44|  4.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.83k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.72k, False: 1.11k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.72k|            else if constexpr( has_apply0_bool ) {
  153|  3.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.72k|            }
  155|  3.72k|         }
  156|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.72k, False: 1.11k]
  ------------------
  157|  3.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.72k|         }
  159|  1.11k|         else {
  160|  1.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.11k|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.83k|      {
   44|  4.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.83k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.83k, 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.83k|            else if constexpr( has_apply0_bool ) {
  153|  4.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.83k|            }
  155|  4.83k|         }
  156|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.83k, False: 0]
  ------------------
  157|  4.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.83k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.83k|      {
   44|  4.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.83k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|  4.83k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.83k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.83k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.83k|      {
   44|  4.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.83k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.83k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.83k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 1.41k]
  ------------------
  143|  3.42k|            if constexpr( has_apply_void ) {
  144|  3.42k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.42k|         }
  156|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 1.41k]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.83k|      {
   44|  4.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.83k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.07k, False: 3.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.07k|            else if constexpr( has_apply0_bool ) {
  153|  1.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.07k|            }
  155|  1.07k|         }
  156|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.07k, False: 3.76k]
  ------------------
  157|  1.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.07k|         }
  159|  3.76k|         else {
  160|  3.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.76k|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.83k|      {
   59|  4.83k|         return Rule::match( in );
   60|  4.83k|      }
_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.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.76k|      else {
  108|  3.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.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|  3.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|  3.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|  3.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|  3.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|  3.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.76k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 351, False: 3.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    351|            else if constexpr( has_apply0_bool ) {
  153|    351|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    351|            }
  155|    351|         }
  156|  3.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 351, False: 3.41k]
  ------------------
  157|    351|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    351|         }
  159|  3.41k|         else {
  160|  3.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.41k|         }
  162|  3.76k|         (void)m( result );
  163|  3.76k|         return result;
  164|  3.76k|      }
  165|  3.76k|   }
_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.76k|      {
   73|  3.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|  3.76k|         else {
   84|  3.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.76k|      }
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.76k|      {
   59|  3.76k|         return Rule::match( in );
   60|  3.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.41k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.41k|      else {
  108|  3.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.41k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 308, False: 3.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|    308|            else if constexpr( has_apply0_bool ) {
  153|    308|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    308|            }
  155|    308|         }
  156|  3.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 308, False: 3.10k]
  ------------------
  157|    308|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    308|         }
  159|  3.10k|         else {
  160|  3.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.10k|         }
  162|  3.41k|         (void)m( result );
  163|  3.41k|         return result;
  164|  3.41k|      }
  165|  3.41k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.41k|      {
   73|  3.41k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.41k|         else {
   84|  3.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.41k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.41k|      {
   59|  3.41k|         return Rule::match( in );
   60|  3.41k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.10k|      else {
  108|  3.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 236, False: 2.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    236|            else if constexpr( has_apply0_bool ) {
  153|    236|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    236|            }
  155|    236|         }
  156|  3.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 236, False: 2.86k]
  ------------------
  157|    236|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    236|         }
  159|  2.86k|         else {
  160|  2.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.86k|         }
  162|  3.10k|         (void)m( result );
  163|  3.10k|         return result;
  164|  3.10k|      }
  165|  3.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.10k|      {
   73|  3.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|  3.10k|         else {
   84|  3.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.10k|      {
   59|  3.10k|         return Rule::match( in );
   60|  3.10k|      }
_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.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.86k|      else {
  108|  2.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.86k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 390, False: 2.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    390|            else if constexpr( has_apply0_bool ) {
  153|    390|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    390|            }
  155|    390|         }
  156|  2.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 390, False: 2.47k]
  ------------------
  157|    390|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    390|         }
  159|  2.47k|         else {
  160|  2.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.47k|         }
  162|  2.86k|         (void)m( result );
  163|  2.86k|         return result;
  164|  2.86k|      }
  165|  2.86k|   }
_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.86k|      {
   73|  2.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.86k|         else {
   84|  2.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.86k|      {
   59|  2.86k|         return Rule::match( in );
   60|  2.86k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.47k|      else {
  108|  2.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.47k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.06k, False: 1.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.06k|            else if constexpr( has_apply0_bool ) {
  153|  1.06k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.06k|            }
  155|  1.06k|         }
  156|  2.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.06k, False: 1.41k]
  ------------------
  157|  1.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.06k|         }
  159|  1.41k|         else {
  160|  1.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.41k|         }
  162|  2.47k|         (void)m( result );
  163|  2.47k|         return result;
  164|  2.47k|      }
  165|  2.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.47k|      {
   73|  2.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.47k|         else {
   84|  2.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.47k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.47k|      {
   59|  2.47k|         return Rule::match( in );
   60|  2.47k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.83k|      else {
  108|  4.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.96k, False: 872]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  4.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.96k, False: 872]
  ------------------
  157|  3.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.96k|         }
  159|    872|         else {
  160|    872|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    872|         }
  162|  4.83k|         (void)m( result );
  163|  4.83k|         return result;
  164|  4.83k|      }
  165|  4.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.83k|      {
   73|  4.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.83k|         else {
   84|  4.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.83k|      {
   59|  4.83k|         return Rule::match( in );
   60|  4.83k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.87k|      else {
  108|  7.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.87k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.87k|            else if constexpr( has_apply0_bool ) {
  153|  7.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.87k|            }
  155|  7.87k|         }
  156|  7.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.87k, False: 0]
  ------------------
  157|  7.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.87k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  7.87k|         (void)m( result );
  163|  7.87k|         return result;
  164|  7.87k|      }
  165|  7.87k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  7.87k|      {
   73|  7.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|  7.87k|         else {
   84|  7.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.87k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.87k|      {
   44|  7.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.87k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.96k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.96k|      else {
  108|  3.96k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.96k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.96k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.96k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.96k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.96k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.96k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.96k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.96k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.96k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.96k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.96k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.96k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.96k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.96k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.96k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.96k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.96k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.96k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.96k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.90k, False: 56]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.90k|            else if constexpr( has_apply0_bool ) {
  153|  3.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.90k|            }
  155|  3.90k|         }
  156|  3.96k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.90k, False: 56]
  ------------------
  157|  3.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.90k|         }
  159|     56|         else {
  160|     56|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     56|         }
  162|  3.96k|         (void)m( result );
  163|  3.96k|         return result;
  164|  3.96k|      }
  165|  3.96k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.96k|      {
   73|  3.96k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.96k|         else {
   84|  3.96k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.96k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.96k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.96k|      {
   44|  3.96k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.96k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.90k|   {
  104|  3.90k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.90k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.90k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.90k|      {
   44|  3.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.90k|      }
_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|   158k|   {
  104|   158k|      if constexpr( !Control< Rule >::enable ) {
  105|   158k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   158k|   }
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|   158k|      {
   44|   158k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   158k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.90k|      else {
  108|  3.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.90k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.72k, False: 187]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.72k|            else if constexpr( has_apply0_bool ) {
  153|  3.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.72k|            }
  155|  3.72k|         }
  156|  3.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.72k, False: 187]
  ------------------
  157|  3.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.72k|         }
  159|    187|         else {
  160|    187|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    187|         }
  162|  3.90k|         (void)m( result );
  163|  3.90k|         return result;
  164|  3.90k|      }
  165|  3.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.90k|      {
   73|  3.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.90k|         else {
   84|  3.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.90k|      {
   59|  3.90k|         return Rule::match( in );
   60|  3.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_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): [True: 0, Folded]
  ------------------
  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): [True: 161k, Folded]
  |  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): [True: 161k, Folded]
  |  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: 159k, False: 2.19k]
  ------------------
  143|   159k|            if constexpr( has_apply_void ) {
  144|   159k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   159k|         }
  156|   161k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 159k, False: 2.19k]
  ------------------
  157|   159k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   159k|         }
  159|  2.19k|         else {
  160|  2.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.19k|         }
  162|   161k|         (void)m( result );
  163|   161k|         return result;
  164|   161k|      }
  165|   161k|   }
_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|   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_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|   161k|      {
   44|   161k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   161k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_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: 159k, False: 2.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   159k|            else if constexpr( has_apply0_bool ) {
  153|   159k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   159k|            }
  155|   159k|         }
  156|   161k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 159k, False: 2.07k]
  ------------------
  157|   159k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   159k|         }
  159|  2.07k|         else {
  160|  2.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.07k|         }
  162|   161k|         (void)m( result );
  163|   161k|         return result;
  164|   161k|      }
  165|   161k|   }
_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|   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_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|   161k|      {
   44|   161k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   161k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   809k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   809k|      else {
  108|   809k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   809k|         using iterator_t = typename ParseInput::iterator_t;
  111|   809k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   809k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   809k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   809k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   809k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   809k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   809k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   809k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   809k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   809k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   809k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   809k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   809k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   809k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   809k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   809k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   809k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   809k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 657k, False: 152k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   657k|            else if constexpr( has_apply0_bool ) {
  153|   657k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   657k|            }
  155|   657k|         }
  156|   809k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 657k, False: 152k]
  ------------------
  157|   657k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   657k|         }
  159|   152k|         else {
  160|   152k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   152k|         }
  162|   809k|         (void)m( result );
  163|   809k|         return result;
  164|   809k|      }
  165|   809k|   }
_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|   809k|      {
   73|   809k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   809k|         else {
   84|   809k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   809k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   809k|      }
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|   809k|      {
   59|   809k|         return Rule::match( in );
   60|   809k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   319k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   319k|      else {
  108|   319k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   319k|         using iterator_t = typename ParseInput::iterator_t;
  111|   319k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   319k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   319k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   319k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   319k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   319k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   319k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   319k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   319k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   319k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   319k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   319k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   319k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   319k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   319k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   319k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   319k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   319k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 319k, 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|   319k|            else if constexpr( has_apply0_bool ) {
  153|   319k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   319k|            }
  155|   319k|         }
  156|   319k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 319k, False: 61]
  ------------------
  157|   319k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   319k|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|   319k|         (void)m( result );
  163|   319k|         return result;
  164|   319k|      }
  165|   319k|   }
_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|   319k|      {
   73|   319k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   319k|         else {
   84|   319k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   319k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   319k|      }
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|   319k|      {
   59|   319k|         return Rule::match( in );
   60|   319k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   319k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   319k|      else {
  108|   319k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   319k|         using iterator_t = typename ParseInput::iterator_t;
  111|   319k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   319k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   319k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   319k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   319k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   319k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   319k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   319k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   319k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   319k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   319k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   319k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   319k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   319k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   319k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   319k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   319k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   319k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 319k, 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|   319k|            else if constexpr( has_apply0_bool ) {
  153|   319k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   319k|            }
  155|   319k|         }
  156|   319k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 319k, False: 58]
  ------------------
  157|   319k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   319k|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|   319k|         (void)m( result );
  163|   319k|         return result;
  164|   319k|      }
  165|   319k|   }
_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|   319k|      {
   73|   319k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   319k|         else {
   84|   319k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   319k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   319k|      }
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|   319k|      {
   44|   319k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   319k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   319k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   319k|      else {
  108|   319k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   319k|         using iterator_t = typename ParseInput::iterator_t;
  111|   319k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   319k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   319k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   319k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   319k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   319k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   319k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   319k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   319k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   319k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   319k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   319k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   319k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   319k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   319k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   319k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   319k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   319k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 168k, False: 150k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   168k|            else if constexpr( has_apply0_bool ) {
  153|   168k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   168k|            }
  155|   168k|         }
  156|   319k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 168k, False: 150k]
  ------------------
  157|   168k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   168k|         }
  159|   150k|         else {
  160|   150k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   150k|         }
  162|   319k|         (void)m( result );
  163|   319k|         return result;
  164|   319k|      }
  165|   319k|   }
_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|   319k|      {
   73|   319k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   319k|         else {
   84|   319k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   319k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   319k|      }
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|   319k|      {
   44|   319k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   319k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   150k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   150k|      else {
  108|   150k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   150k|         using iterator_t = typename ParseInput::iterator_t;
  111|   150k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   150k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   150k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   150k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   150k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   150k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   150k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   150k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   150k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   150k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   150k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   150k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   150k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   150k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   150k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   150k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   150k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   150k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 150k, 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|   150k|            else if constexpr( has_apply0_bool ) {
  153|   150k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   150k|            }
  155|   150k|         }
  156|   150k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 150k, False: 58]
  ------------------
  157|   150k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   150k|         }
  159|     58|         else {
  160|     58|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     58|         }
  162|   150k|         (void)m( result );
  163|   150k|         return result;
  164|   150k|      }
  165|   150k|   }
_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|   150k|      {
   73|   150k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   150k|         else {
   84|   150k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   150k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   150k|      }
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|   150k|      {
   59|   150k|         return Rule::match( in );
   60|   150k|      }
_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|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.47k, False: 19.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.47k|            else if constexpr( has_apply0_bool ) {
  153|  2.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.47k|            }
  155|  2.47k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.47k, False: 19.8k]
  ------------------
  157|  2.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.47k|         }
  159|  19.8k|         else {
  160|  19.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.8k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_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|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  22.3k|      {
   44|  22.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.3k|      }
_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|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.47k, False: 19.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.47k|            else if constexpr( has_apply0_bool ) {
  153|  2.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.47k|            }
  155|  2.47k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.47k, False: 19.8k]
  ------------------
  157|  2.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.47k|         }
  159|  19.8k|         else {
  160|  19.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.8k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_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|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_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|  22.3k|      {
   44|  22.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.3k|      }
_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|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 22.3k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 22.3k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.08k, False: 19.2k]
  ------------------
  143|  3.08k|            if constexpr( has_apply_void ) {
  144|  3.08k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.08k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.08k, False: 19.2k]
  ------------------
  157|  3.08k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.08k|         }
  159|  19.2k|         else {
  160|  19.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.2k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_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|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  22.3k|      {
   59|  22.3k|         return Rule::match( in );
   60|  22.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.16k|      else {
  108|  9.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.23k, 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|  7.23k|            else if constexpr( has_apply0_bool ) {
  153|  7.23k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.23k|            }
  155|  7.23k|         }
  156|  9.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.23k, False: 1.93k]
  ------------------
  157|  7.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.23k|         }
  159|  1.93k|         else {
  160|  1.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.93k|         }
  162|  9.16k|         (void)m( result );
  163|  9.16k|         return result;
  164|  9.16k|      }
  165|  9.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  9.16k|      {
   73|  9.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.16k|         else {
   84|  9.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.16k|      {
   44|  9.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.16k|      else {
  108|  9.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.16k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.23k, 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|  7.23k|            else if constexpr( has_apply0_bool ) {
  153|  7.23k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.23k|            }
  155|  7.23k|         }
  156|  9.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.23k, False: 1.93k]
  ------------------
  157|  7.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.23k|         }
  159|  1.93k|         else {
  160|  1.93k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.93k|         }
  162|  9.16k|         (void)m( result );
  163|  9.16k|         return result;
  164|  9.16k|      }
  165|  9.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.16k|      {
   73|  9.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.16k|         else {
   84|  9.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.16k|      {
   59|  9.16k|         return Rule::match( in );
   60|  9.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  18.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.8k|      else {
  108|  18.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.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|  18.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|  18.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|  18.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|  18.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.66k, False: 12.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.66k|            else if constexpr( has_apply0_bool ) {
  153|  6.66k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.66k|            }
  155|  6.66k|         }
  156|  18.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.66k, False: 12.2k]
  ------------------
  157|  6.66k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.66k|         }
  159|  12.2k|         else {
  160|  12.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.2k|         }
  162|  18.8k|         (void)m( result );
  163|  18.8k|         return result;
  164|  18.8k|      }
  165|  18.8k|   }
_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|  18.8k|      {
   73|  18.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|  18.8k|         else {
   84|  18.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.8k|      }
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|  18.8k|      {
   59|  18.8k|         return Rule::match( in );
   60|  18.8k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.47k, False: 598]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.47k|            else if constexpr( has_apply0_bool ) {
  153|  2.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.47k|            }
  155|  2.47k|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.47k, False: 598]
  ------------------
  157|  2.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.47k|         }
  159|    598|         else {
  160|    598|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    598|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.32k, False: 751]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.32k|            else if constexpr( has_apply0_bool ) {
  153|  2.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.32k|            }
  155|  2.32k|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.32k, False: 751]
  ------------------
  157|  2.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.32k|         }
  159|    751|         else {
  160|    751|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    751|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.07k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.07k|            else if constexpr( has_apply0_bool ) {
  153|  3.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.07k|            }
  155|  3.07k|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.07k, False: 0]
  ------------------
  157|  3.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.07k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|  3.07k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.07k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.07k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.07k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.07k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.31k, False: 1.75k]
  ------------------
  143|  1.31k|            if constexpr( has_apply_void ) {
  144|  1.31k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.31k|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.31k, False: 1.75k]
  ------------------
  157|  1.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.31k|         }
  159|  1.75k|         else {
  160|  1.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.75k|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 203, False: 2.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 203, False: 2.86k]
  ------------------
  157|    203|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    203|         }
  159|  2.86k|         else {
  160|  2.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.86k|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.07k|      {
   59|  3.07k|         return Rule::match( in );
   60|  3.07k|      }
_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.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.86k|      else {
  108|  2.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.86k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 99, 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|     99|            else if constexpr( has_apply0_bool ) {
  153|     99|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     99|            }
  155|     99|         }
  156|  2.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 99, False: 2.77k]
  ------------------
  157|     99|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     99|         }
  159|  2.77k|         else {
  160|  2.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.77k|         }
  162|  2.86k|         (void)m( result );
  163|  2.86k|         return result;
  164|  2.86k|      }
  165|  2.86k|   }
_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.86k|      {
   73|  2.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.86k|         else {
   84|  2.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.86k|      {
   59|  2.86k|         return Rule::match( in );
   60|  2.86k|      }
_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.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: 321, False: 2.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|    321|            else if constexpr( has_apply0_bool ) {
  153|    321|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    321|            }
  155|    321|         }
  156|  2.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 321, False: 2.44k]
  ------------------
  157|    321|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    321|         }
  159|  2.44k|         else {
  160|  2.44k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.44k|         }
  162|  2.77k|         (void)m( result );
  163|  2.77k|         return result;
  164|  2.77k|      }
  165|  2.77k|   }
_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.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_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.77k|      {
   59|  2.77k|         return Rule::match( in );
   60|  2.77k|      }
_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.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.44k|      else {
  108|  2.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 239, 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|    239|            else if constexpr( has_apply0_bool ) {
  153|    239|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    239|            }
  155|    239|         }
  156|  2.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 239, False: 2.21k]
  ------------------
  157|    239|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    239|         }
  159|  2.21k|         else {
  160|  2.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.21k|         }
  162|  2.44k|         (void)m( result );
  163|  2.44k|         return result;
  164|  2.44k|      }
  165|  2.44k|   }
_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.44k|      {
   73|  2.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|  2.44k|         else {
   84|  2.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.44k|      }
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.44k|      {
   59|  2.44k|         return Rule::match( in );
   60|  2.44k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.21k|      else {
  108|  2.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 256, 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|    256|            else if constexpr( has_apply0_bool ) {
  153|    256|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    256|            }
  155|    256|         }
  156|  2.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 256, False: 1.95k]
  ------------------
  157|    256|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    256|         }
  159|  1.95k|         else {
  160|  1.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.95k|         }
  162|  2.21k|         (void)m( result );
  163|  2.21k|         return result;
  164|  2.21k|      }
  165|  2.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.21k|      {
   73|  2.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.21k|         else {
   84|  2.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.21k|      {
   59|  2.21k|         return Rule::match( in );
   60|  2.21k|      }
_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.95k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.95k|      else {
  108|  1.95k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.95k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.95k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.95k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.95k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.95k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.95k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.95k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.95k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.95k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.95k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.95k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.95k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.95k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.95k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.95k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.95k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.95k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.95k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.95k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 1.75k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  1.95k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 1.75k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  1.75k|         else {
  160|  1.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.75k|         }
  162|  1.95k|         (void)m( result );
  163|  1.95k|         return result;
  164|  1.95k|      }
  165|  1.95k|   }
_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.95k|      {
   73|  1.95k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.95k|         else {
   84|  1.95k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.95k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.95k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.95k|      {
   59|  1.95k|         return Rule::match( in );
   60|  1.95k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.53k, False: 540]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.53k, False: 540]
  ------------------
  157|  2.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.53k|         }
  159|    540|         else {
  160|    540|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    540|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.07k|      {
   59|  3.07k|         return Rule::match( in );
   60|  3.07k|      }
_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.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.97k|      else {
  108|  4.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.97k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.97k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.97k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.97k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.97k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.97k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.97k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.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|  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|  4.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.97k, False: 0]
  ------------------
  157|  4.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.97k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.97k|         (void)m( result );
  163|  4.97k|         return result;
  164|  4.97k|      }
  165|  4.97k|   }
_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.97k|      {
   73|  4.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.97k|         else {
   84|  4.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.97k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.97k|      {
   44|  4.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.97k|      }
_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.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.44k, False: 85]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.44k|            else if constexpr( has_apply0_bool ) {
  153|  2.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.44k|            }
  155|  2.44k|         }
  156|  2.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.44k, False: 85]
  ------------------
  157|  2.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.44k|         }
  159|     85|         else {
  160|     85|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     85|         }
  162|  2.53k|         (void)m( result );
  163|  2.53k|         return result;
  164|  2.53k|      }
  165|  2.53k|   }
_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.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_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.53k|      {
   44|  2.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.53k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.46k|   {
  104|  2.46k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.46k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.46k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.46k|      {
   44|  2.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.46k|      }
_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.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_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.77k|      {
   44|  4.77k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.77k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.44k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.44k|      else {
  108|  2.44k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.44k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.44k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.44k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.44k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.44k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.44k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.44k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.44k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.44k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.44k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.44k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.32k, False: 126]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.32k|            else if constexpr( has_apply0_bool ) {
  153|  2.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.32k|            }
  155|  2.32k|         }
  156|  2.44k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.32k, False: 126]
  ------------------
  157|  2.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.32k|         }
  159|    126|         else {
  160|    126|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    126|         }
  162|  2.44k|         (void)m( result );
  163|  2.44k|         return result;
  164|  2.44k|      }
  165|  2.44k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.44k|      {
   73|  2.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|  2.44k|         else {
   84|  2.44k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.44k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.44k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.44k|      {
   59|  2.44k|         return Rule::match( in );
   60|  2.44k|      }
_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|  6.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.12k|      else {
  108|  6.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.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|  6.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.12k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.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|  6.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|  6.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|  6.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.12k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.97k, False: 1.14k]
  ------------------
  143|  4.97k|            if constexpr( has_apply_void ) {
  144|  4.97k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.97k|         }
  156|  6.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.92k, False: 1.19k]
  ------------------
  157|  4.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.92k|         }
  159|  1.19k|         else {
  160|  1.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.19k|         }
  162|  6.12k|         (void)m( result );
  163|  6.12k|         return result;
  164|  6.12k|      }
  165|  6.12k|   }
_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|  6.12k|      {
   73|  6.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|  6.12k|         else {
   84|  6.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.12k|      }
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|  6.12k|      {
   44|  6.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.12k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.12k|      else {
  108|  6.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.22k, False: 893]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.22k|            else if constexpr( has_apply0_bool ) {
  153|  5.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.22k|            }
  155|  5.22k|         }
  156|  6.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.22k, False: 893]
  ------------------
  157|  5.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.22k|         }
  159|    893|         else {
  160|    893|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    893|         }
  162|  6.12k|         (void)m( result );
  163|  6.12k|         return result;
  164|  6.12k|      }
  165|  6.12k|   }
_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|  6.12k|      {
   73|  6.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|  6.12k|         else {
   84|  6.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.12k|      }
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|  6.12k|      {
   59|  6.12k|         return Rule::match( in );
   60|  6.12k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.22k|   {
  104|  5.22k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.22k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.22k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.22k|      {
   44|  5.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.22k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.22k|      else {
  108|  5.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.22k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.97k, False: 253]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  5.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.97k, False: 253]
  ------------------
  157|  4.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.97k|         }
  159|    253|         else {
  160|    253|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    253|         }
  162|  5.22k|         (void)m( result );
  163|  5.22k|         return result;
  164|  5.22k|      }
  165|  5.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.22k|      {
   73|  5.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.22k|         else {
   84|  5.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.22k|      {
   44|  5.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.22k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.25M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.25M|      else {
  108|  8.25M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.25M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.25M|         constexpr bool has_apply_void = enable_action && internal::has_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.25M|         constexpr bool has_apply_bool = enable_action && internal::has_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.25M|         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.25M|         constexpr bool has_apply0_void = enable_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.25M|         constexpr bool has_apply0_bool = enable_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.25M|         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.25M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.25M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.25M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.25M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.25M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.25M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.25M|         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.25M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.25M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.25M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.25M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.25M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.97k, False: 8.25M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  8.25M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.97k, False: 8.25M]
  ------------------
  157|  4.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.97k|         }
  159|  8.25M|         else {
  160|  8.25M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.25M|         }
  162|  8.25M|         (void)m( result );
  163|  8.25M|         return result;
  164|  8.25M|      }
  165|  8.25M|   }
_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|  8.25M|      {
   73|  8.25M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.25M|         else {
   84|  8.25M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.25M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.25M|      }
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|  8.25M|      {
   59|  8.25M|         return Rule::match( in );
   60|  8.25M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.25M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.25M|      else {
  108|  8.25M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.25M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.25M|         constexpr bool has_apply_void = enable_action && internal::has_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.25M|         constexpr bool has_apply_bool = enable_action && internal::has_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.25M|         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.25M|         constexpr bool has_apply0_void = enable_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.25M|         constexpr bool has_apply0_bool = enable_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.25M|         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.25M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.25M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.25M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.25M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.25M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.25M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.25M|         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.25M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.25M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.25M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.25M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.25M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.25M, False: 253]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.25M|            else if constexpr( has_apply0_bool ) {
  153|  8.25M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.25M|            }
  155|  8.25M|         }
  156|  8.25M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.25M, False: 253]
  ------------------
  157|  8.25M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.25M|         }
  159|    253|         else {
  160|    253|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    253|         }
  162|  8.25M|         (void)m( result );
  163|  8.25M|         return result;
  164|  8.25M|      }
  165|  8.25M|   }
_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|  8.25M|      {
   73|  8.25M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.25M|         else {
   84|  8.25M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.25M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.25M|      }
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|  8.25M|      {
   44|  8.25M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.25M|      }
_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|  8.25M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.25M|      else {
  108|  8.25M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.25M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.25M|         constexpr bool has_apply_void = enable_action && internal::has_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.25M|         constexpr bool has_apply_bool = enable_action && internal::has_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.25M|         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.25M|         constexpr bool has_apply0_void = enable_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.25M|         constexpr bool has_apply0_bool = enable_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.25M|         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.25M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.25M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.25M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.25M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.25M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.25M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.25M|         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.25M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.25M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.25M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.25M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.25M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 101k, False: 8.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|   101k|            else if constexpr( has_apply0_bool ) {
  153|   101k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   101k|            }
  155|   101k|         }
  156|  8.25M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 101k, False: 8.14M]
  ------------------
  157|   101k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   101k|         }
  159|  8.14M|         else {
  160|  8.14M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.14M|         }
  162|  8.25M|         (void)m( result );
  163|  8.25M|         return result;
  164|  8.25M|      }
  165|  8.25M|   }
_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|  8.25M|      {
   73|  8.25M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.25M|         else {
   84|  8.25M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.25M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.25M|      }
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|  8.25M|      {
   44|  8.25M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.25M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.25M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.25M|      else {
  108|  8.25M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.25M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.25M|         constexpr bool has_apply_void = enable_action && internal::has_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.25M|         constexpr bool has_apply_bool = enable_action && internal::has_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.25M|         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.25M|         constexpr bool has_apply0_void = enable_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.25M|         constexpr bool has_apply0_bool = enable_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.25M|         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.25M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.25M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.25M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.25M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.25M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.25M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.25M|         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.25M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.25M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.25M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.25M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.25M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 101k, False: 8.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|   101k|            else if constexpr( has_apply0_bool ) {
  153|   101k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   101k|            }
  155|   101k|         }
  156|  8.25M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 101k, False: 8.14M]
  ------------------
  157|   101k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   101k|         }
  159|  8.14M|         else {
  160|  8.14M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.14M|         }
  162|  8.25M|         (void)m( result );
  163|  8.25M|         return result;
  164|  8.25M|      }
  165|  8.25M|   }
_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|  8.25M|      {
   73|  8.25M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.25M|         else {
   84|  8.25M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.25M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.25M|      }
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|  8.25M|      {
   59|  8.25M|         return Rule::match( in );
   60|  8.25M|      }
_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|   101k|   {
  104|   101k|      if constexpr( !Control< Rule >::enable ) {
  105|   101k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   101k|   }
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|   101k|      {
   44|   101k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   101k|      }
_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|   101k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   101k|      else {
  108|   101k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   101k|         using iterator_t = typename ParseInput::iterator_t;
  111|   101k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   101k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   101k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   101k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   101k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   101k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   101k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   101k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   101k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   101k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   101k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   101k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   101k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   101k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   101k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   101k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   101k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   101k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 101k, 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|   101k|            else if constexpr( has_apply0_bool ) {
  153|   101k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   101k|            }
  155|   101k|         }
  156|   101k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 101k, False: 65]
  ------------------
  157|   101k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   101k|         }
  159|     65|         else {
  160|     65|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     65|         }
  162|   101k|         (void)m( result );
  163|   101k|         return result;
  164|   101k|      }
  165|   101k|   }
_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|   101k|      {
   73|   101k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   101k|         else {
   84|   101k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   101k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   101k|      }
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|   101k|      {
   44|   101k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   101k|      }
_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|   101k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   101k|      else {
  108|   101k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   101k|         using iterator_t = typename ParseInput::iterator_t;
  111|   101k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   101k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   101k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   101k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   101k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   101k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   101k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   101k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   101k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   101k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   101k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   101k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   101k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   101k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   101k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   101k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   101k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   101k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.5k, False: 77.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|  24.5k|            else if constexpr( has_apply0_bool ) {
  153|  24.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.5k|            }
  155|  24.5k|         }
  156|   101k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.5k, False: 77.2k]
  ------------------
  157|  24.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.5k|         }
  159|  77.2k|         else {
  160|  77.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  77.2k|         }
  162|   101k|         (void)m( result );
  163|   101k|         return result;
  164|   101k|      }
  165|   101k|   }
_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|   101k|      {
   73|   101k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   101k|         else {
   84|   101k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   101k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   101k|      }
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|   101k|      {
   44|   101k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   101k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   101k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   101k|      else {
  108|   101k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   101k|         using iterator_t = typename ParseInput::iterator_t;
  111|   101k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   101k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   101k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   101k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   101k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   101k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   101k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   101k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   101k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   101k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   101k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   101k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   101k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   101k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   101k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   101k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   101k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   101k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.5k, False: 77.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|  24.5k|            else if constexpr( has_apply0_bool ) {
  153|  24.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.5k|            }
  155|  24.5k|         }
  156|   101k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.5k, False: 77.2k]
  ------------------
  157|  24.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.5k|         }
  159|  77.2k|         else {
  160|  77.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  77.2k|         }
  162|   101k|         (void)m( result );
  163|   101k|         return result;
  164|   101k|      }
  165|   101k|   }
_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|   101k|      {
   73|   101k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   101k|         else {
   84|   101k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   101k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   101k|      }
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|   101k|      {
   59|   101k|         return Rule::match( in );
   60|   101k|      }
_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|  24.5k|   {
  104|  24.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  24.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|  24.5k|   }
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|  24.5k|      {
   44|  24.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.5k|      }
_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|  24.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.5k|      else {
  108|  24.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  24.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  24.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|  24.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|  24.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|  24.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|  24.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.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|  24.5k|            else if constexpr( has_apply0_bool ) {
  153|  24.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.5k|            }
  155|  24.5k|         }
  156|  24.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.5k, False: 37]
  ------------------
  157|  24.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.5k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|  24.5k|         (void)m( result );
  163|  24.5k|         return result;
  164|  24.5k|      }
  165|  24.5k|   }
_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|  24.5k|      {
   73|  24.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|  24.5k|         else {
   84|  24.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  24.5k|      {
   44|  24.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  49.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  49.0k|      else {
  108|  49.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  49.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  49.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|  49.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|  49.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|  49.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|  49.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|  49.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|  49.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  49.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  49.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  49.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|  49.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  49.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  49.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|  49.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  49.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  49.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  49.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  49.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 49.0k, 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|  49.0k|            else if constexpr( has_apply0_bool ) {
  153|  49.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  49.0k|            }
  155|  49.0k|         }
  156|  49.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 49.0k, False: 37]
  ------------------
  157|  49.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  49.0k|         }
  159|     37|         else {
  160|     37|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     37|         }
  162|  49.0k|         (void)m( result );
  163|  49.0k|         return result;
  164|  49.0k|      }
  165|  49.0k|   }
_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|  49.0k|      {
   73|  49.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|  49.0k|         else {
   84|  49.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  49.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  49.0k|      }
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|  49.0k|      {
   59|  49.0k|         return Rule::match( in );
   60|  49.0k|      }
_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|  77.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  77.2k|      else {
  108|  77.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  77.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  77.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|  77.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|  77.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|  77.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|  77.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|  77.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|  77.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  77.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  77.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  77.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|  77.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  77.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  77.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|  77.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  77.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  77.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  77.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  77.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.1k, False: 43.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  34.1k|            else if constexpr( has_apply0_bool ) {
  153|  34.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.1k|            }
  155|  34.1k|         }
  156|  77.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.1k, False: 43.0k]
  ------------------
  157|  34.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.1k|         }
  159|  43.0k|         else {
  160|  43.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.0k|         }
  162|  77.2k|         (void)m( result );
  163|  77.2k|         return result;
  164|  77.2k|      }
  165|  77.2k|   }
_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|  77.2k|      {
   73|  77.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|  77.2k|         else {
   84|  77.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  77.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  77.2k|      }
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|  77.2k|      {
   44|  77.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  77.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   115k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   115k|      else {
  108|   115k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   115k|         using iterator_t = typename ParseInput::iterator_t;
  111|   115k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   115k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   115k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   115k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   115k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   115k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   115k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   115k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   115k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   115k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   115k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   115k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   115k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   115k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   115k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   115k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   115k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   115k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.9k, False: 75.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|  39.9k|            else if constexpr( has_apply0_bool ) {
  153|  39.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.9k|            }
  155|  39.9k|         }
  156|   115k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.9k, False: 75.9k]
  ------------------
  157|  39.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.9k|         }
  159|  75.9k|         else {
  160|  75.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  75.9k|         }
  162|   115k|         (void)m( result );
  163|   115k|         return result;
  164|   115k|      }
  165|   115k|   }
_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|   115k|      {
   73|   115k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   115k|         else {
   84|   115k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   115k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   115k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   115k|      {
   59|   115k|         return Rule::match( in );
   60|   115k|      }
_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|  34.1k|   {
  104|  34.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  34.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|  34.1k|   }
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|  34.1k|      {
   44|  34.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.1k|      }
_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|  34.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.1k|      else {
  108|  34.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.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|  34.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|  34.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|  34.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|  34.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|  34.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|  34.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.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|  34.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.1k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  34.1k|            else if constexpr( has_apply0_bool ) {
  153|  34.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.1k|            }
  155|  34.1k|         }
  156|  34.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.1k, False: 0]
  ------------------
  157|  34.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  34.1k|         (void)m( result );
  163|  34.1k|         return result;
  164|  34.1k|      }
  165|  34.1k|   }
_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|  34.1k|      {
   73|  34.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|  34.1k|         else {
   84|  34.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.1k|      }
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|  34.1k|      {
   44|  34.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.1k|      }
_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|  43.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.0k|      else {
  108|  43.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.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|  43.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|  43.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|  43.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|  43.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|  43.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|  43.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.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|  43.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.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|  43.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.7k, 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|  41.7k|            else if constexpr( has_apply0_bool ) {
  153|  41.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.7k|            }
  155|  41.7k|         }
  156|  43.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.7k, False: 1.22k]
  ------------------
  157|  41.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.7k|         }
  159|  1.22k|         else {
  160|  1.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.22k|         }
  162|  43.0k|         (void)m( result );
  163|  43.0k|         return result;
  164|  43.0k|      }
  165|  43.0k|   }
_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|  43.0k|      {
   73|  43.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|  43.0k|         else {
   84|  43.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.0k|      }
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|  43.0k|      {
   59|  43.0k|         return Rule::match( in );
   60|  43.0k|      }
_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.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.22k|      else {
  108|  1.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.22k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.19k, False: 28]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.19k|            else if constexpr( has_apply0_bool ) {
  153|  1.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.19k|            }
  155|  1.19k|         }
  156|  1.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.19k, False: 28]
  ------------------
  157|  1.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.19k|         }
  159|     28|         else {
  160|     28|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     28|         }
  162|  1.22k|         (void)m( result );
  163|  1.22k|         return result;
  164|  1.22k|      }
  165|  1.22k|   }
_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.22k|      {
   73|  1.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.22k|         else {
   84|  1.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.22k|      {
   59|  1.22k|         return Rule::match( in );
   60|  1.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.14M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.14M|      else {
  108|  8.14M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.14M|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.14M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.14M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.14M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.14M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.14M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.14M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.14M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.14M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.14M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.14M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.14M, False: 188]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.14M|            else if constexpr( has_apply0_bool ) {
  153|  8.14M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.14M|            }
  155|  8.14M|         }
  156|  8.14M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.14M, False: 188]
  ------------------
  157|  8.14M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.14M|         }
  159|    188|         else {
  160|    188|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    188|         }
  162|  8.14M|         (void)m( result );
  163|  8.14M|         return result;
  164|  8.14M|      }
  165|  8.14M|   }
_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|  8.14M|      {
   73|  8.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|  8.14M|         else {
   84|  8.14M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.14M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.14M|      }
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|  8.14M|      {
   59|  8.14M|         return Rule::match( in );
   60|  8.14M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.5k|      else {
  108|  19.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.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|  19.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|  19.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|  19.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|  19.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.14k, False: 16.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.14k|            else if constexpr( has_apply0_bool ) {
  153|  3.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.14k|            }
  155|  3.14k|         }
  156|  19.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.14k, False: 16.4k]
  ------------------
  157|  3.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.14k|         }
  159|  16.4k|         else {
  160|  16.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4k|         }
  162|  19.5k|         (void)m( result );
  163|  19.5k|         return result;
  164|  19.5k|      }
  165|  19.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|  19.5k|      {
   73|  19.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|  19.5k|         else {
   84|  19.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  19.5k|      {
   44|  19.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.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|  19.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.5k|      else {
  108|  19.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.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|  19.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|  19.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|  19.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|  19.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.14k, False: 16.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.14k|            else if constexpr( has_apply0_bool ) {
  153|  3.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.14k|            }
  155|  3.14k|         }
  156|  19.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.14k, False: 16.4k]
  ------------------
  157|  3.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.14k|         }
  159|  16.4k|         else {
  160|  16.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4k|         }
  162|  19.5k|         (void)m( result );
  163|  19.5k|         return result;
  164|  19.5k|      }
  165|  19.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|  19.5k|      {
   73|  19.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|  19.5k|         else {
   84|  19.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  19.5k|      {
   44|  19.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.5k|      else {
  108|  19.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  19.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 19.5k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  19.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|  19.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|  19.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|  19.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.5k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  19.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 19.5k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.25k, False: 13.2k]
  ------------------
  143|  6.25k|            if constexpr( has_apply_void ) {
  144|  6.25k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.25k|         }
  156|  19.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.24k, False: 13.3k]
  ------------------
  157|  6.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.24k|         }
  159|  13.3k|         else {
  160|  13.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.3k|         }
  162|  19.5k|         (void)m( result );
  163|  19.5k|         return result;
  164|  19.5k|      }
  165|  19.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|  19.5k|      {
   73|  19.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|  19.5k|         else {
   84|  19.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  19.5k|      {
   59|  19.5k|         return Rule::match( in );
   60|  19.5k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   652k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   652k|      else {
  108|   652k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   652k|         using iterator_t = typename ParseInput::iterator_t;
  111|   652k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   652k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   652k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   652k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   652k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   652k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   652k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   652k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   652k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   652k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   652k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   652k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   652k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   652k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   652k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   652k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   652k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   652k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 649k, False: 2.33k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   649k|            else if constexpr( has_apply0_bool ) {
  153|   649k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   649k|            }
  155|   649k|         }
  156|   652k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 649k, False: 2.33k]
  ------------------
  157|   649k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   649k|         }
  159|  2.33k|         else {
  160|  2.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.33k|         }
  162|   652k|         (void)m( result );
  163|   652k|         return result;
  164|   652k|      }
  165|   652k|   }
_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|   652k|      {
   73|   652k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   652k|         else {
   84|   652k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   652k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   652k|      }
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|   652k|      {
   44|   652k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   652k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   652k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   652k|      else {
  108|   652k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   652k|         using iterator_t = typename ParseInput::iterator_t;
  111|   652k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   652k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   652k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   652k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   652k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   652k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   652k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   652k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   652k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   652k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   652k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   652k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   652k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   652k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   652k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   652k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   652k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   652k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 649k, False: 2.33k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   649k|            else if constexpr( has_apply0_bool ) {
  153|   649k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   649k|            }
  155|   649k|         }
  156|   652k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 649k, False: 2.33k]
  ------------------
  157|   649k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   649k|         }
  159|  2.33k|         else {
  160|  2.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.33k|         }
  162|   652k|         (void)m( result );
  163|   652k|         return result;
  164|   652k|      }
  165|   652k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   652k|      {
   73|   652k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   652k|         else {
   84|   652k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   652k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   652k|      }
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|   652k|      {
   59|   652k|         return Rule::match( in );
   60|   652k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   698k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   698k|      else {
  108|   698k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   698k|         using iterator_t = typename ParseInput::iterator_t;
  111|   698k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   698k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   698k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   698k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   698k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   698k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   698k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   698k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   698k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   698k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   698k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   698k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   698k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   698k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   698k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   698k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   698k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   698k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.0k, False: 656k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.0k|            else if constexpr( has_apply0_bool ) {
  153|  42.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.0k|            }
  155|  42.0k|         }
  156|   698k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.0k, False: 656k]
  ------------------
  157|  42.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.0k|         }
  159|   656k|         else {
  160|   656k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   656k|         }
  162|   698k|         (void)m( result );
  163|   698k|         return result;
  164|   698k|      }
  165|   698k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   698k|      {
   73|   698k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   698k|         else {
   84|   698k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   698k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   698k|      }
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|   698k|      {
   59|   698k|         return Rule::match( in );
   60|   698k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.14k, False: 3.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.14k|            else if constexpr( has_apply0_bool ) {
  153|  3.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.14k|            }
  155|  3.14k|         }
  156|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.14k, False: 3.07k]
  ------------------
  157|  3.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.14k|         }
  159|  3.07k|         else {
  160|  3.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.07k|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.91k, False: 4.30k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 4.30k]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|  4.30k|         else {
  160|  4.30k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.30k|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.21k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.21k|            else if constexpr( has_apply0_bool ) {
  153|  6.21k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.21k|            }
  155|  6.21k|         }
  156|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.21k, False: 0]
  ------------------
  157|  6.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.21k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|  6.21k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.21k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.21k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.21k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.34k, False: 4.87k]
  ------------------
  143|  1.34k|            if constexpr( has_apply_void ) {
  144|  1.34k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), 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.34k|         }
  156|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.34k, False: 4.87k]
  ------------------
  157|  1.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.34k|         }
  159|  4.87k|         else {
  160|  4.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.87k|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44, False: 6.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|     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|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44, False: 6.17k]
  ------------------
  157|     44|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     44|         }
  159|  6.17k|         else {
  160|  6.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.17k|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.21k|      {
   59|  6.21k|         return Rule::match( in );
   60|  6.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.17k|      else {
  108|  6.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 256, False: 5.91k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    256|            else if constexpr( has_apply0_bool ) {
  153|    256|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    256|            }
  155|    256|         }
  156|  6.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 256, False: 5.91k]
  ------------------
  157|    256|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    256|         }
  159|  5.91k|         else {
  160|  5.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.91k|         }
  162|  6.17k|         (void)m( result );
  163|  6.17k|         return result;
  164|  6.17k|      }
  165|  6.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.17k|      {
   73|  6.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|  6.17k|         else {
   84|  6.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.17k|      {
   59|  6.17k|         return Rule::match( in );
   60|  6.17k|      }
_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.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.91k|      else {
  108|  5.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.91k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 229, False: 5.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  5.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 229, False: 5.69k]
  ------------------
  157|    229|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    229|         }
  159|  5.69k|         else {
  160|  5.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.69k|         }
  162|  5.91k|         (void)m( result );
  163|  5.91k|         return result;
  164|  5.91k|      }
  165|  5.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.91k|      {
   73|  5.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.91k|         else {
   84|  5.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.91k|      {
   59|  5.91k|         return Rule::match( in );
   60|  5.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.69k|      else {
  108|  5.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.69k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 510, False: 5.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|    510|            else if constexpr( has_apply0_bool ) {
  153|    510|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    510|            }
  155|    510|         }
  156|  5.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 510, False: 5.18k]
  ------------------
  157|    510|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    510|         }
  159|  5.18k|         else {
  160|  5.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.18k|         }
  162|  5.69k|         (void)m( result );
  163|  5.69k|         return result;
  164|  5.69k|      }
  165|  5.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.69k|      {
   73|  5.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.69k|         else {
   84|  5.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.69k|      {
   59|  5.69k|         return Rule::match( in );
   60|  5.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.18k|      else {
  108|  5.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.18k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.18k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.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|  5.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|  5.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|  5.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|  5.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 114, False: 5.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|    114|            else if constexpr( has_apply0_bool ) {
  153|    114|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    114|            }
  155|    114|         }
  156|  5.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 114, False: 5.06k]
  ------------------
  157|    114|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    114|         }
  159|  5.06k|         else {
  160|  5.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.06k|         }
  162|  5.18k|         (void)m( result );
  163|  5.18k|         return result;
  164|  5.18k|      }
  165|  5.18k|   }
_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.18k|      {
   73|  5.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|  5.18k|         else {
   84|  5.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.18k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.18k|      {
   59|  5.18k|         return Rule::match( in );
   60|  5.18k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.06k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.06k|      else {
  108|  5.06k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.06k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.06k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.06k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.06k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.06k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.06k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.06k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.06k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.06k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.06k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.06k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.06k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.06k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.06k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.06k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.06k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.06k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.06k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.06k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 4.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|    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|  5.06k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 4.87k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  4.87k|         else {
  160|  4.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.87k|         }
  162|  5.06k|         (void)m( result );
  163|  5.06k|         return result;
  164|  5.06k|      }
  165|  5.06k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.06k|      {
   73|  5.06k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.06k|         else {
   84|  5.06k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.06k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.06k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.06k|      {
   59|  5.06k|         return Rule::match( in );
   60|  5.06k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.21k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.78k, False: 2.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  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|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.78k, False: 2.43k]
  ------------------
  157|  3.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.78k|         }
  159|  2.43k|         else {
  160|  2.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.43k|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.21k|      {
   59|  6.21k|         return Rule::match( in );
   60|  6.21k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.33k|      else {
  108|  6.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.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|  6.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|  6.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|  6.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|  6.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.33k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.33k, 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.33k|            else if constexpr( has_apply0_bool ) {
  153|  6.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.33k|            }
  155|  6.33k|         }
  156|  6.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.33k, False: 0]
  ------------------
  157|  6.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.33k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.33k|         (void)m( result );
  163|  6.33k|         return result;
  164|  6.33k|      }
  165|  6.33k|   }
_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.33k|      {
   73|  6.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|  6.33k|         else {
   84|  6.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.33k|      {
   44|  6.33k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.33k|      }
_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.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: 2.55k, 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.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|  3.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.55k, False: 1.23k]
  ------------------
  157|  2.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.55k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  3.78k|         (void)m( result );
  163|  3.78k|         return result;
  164|  3.78k|      }
  165|  3.78k|   }
_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.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_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.78k|      {
   44|  3.78k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.78k|      }
_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.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_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.65k|      {
   44|  3.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.65k|      }
_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|   644k|   {
  104|   644k|      if constexpr( !Control< Rule >::enable ) {
  105|   644k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   644k|   }
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|   644k|      {
   44|   644k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   644k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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: 1.91k, False: 637]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.55k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 637]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|    637|         else {
  160|    637|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    637|         }
  162|  2.55k|         (void)m( result );
  163|  2.55k|         return result;
  164|  2.55k|      }
  165|  2.55k|   }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser17condition_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   649k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   649k|      else {
  108|   649k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   649k|         using iterator_t = typename ParseInput::iterator_t;
  111|   649k|         constexpr bool has_apply_void = 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|   649k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   649k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 649k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   649k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   649k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   649k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   649k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   649k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   649k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   649k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   649k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   649k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   649k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   649k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 649k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   649k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   649k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   649k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   649k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 647k, False: 1.49k]
  ------------------
  143|   647k|            if constexpr( has_apply_void ) {
  144|   647k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   647k|         }
  156|   649k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 645k, False: 3.43k]
  ------------------
  157|   645k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   645k|         }
  159|  3.43k|         else {
  160|  3.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.43k|         }
  162|   649k|         (void)m( result );
  163|   649k|         return result;
  164|   649k|      }
  165|   649k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   649k|      {
   73|   649k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   649k|         else {
   84|   649k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   649k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   649k|      }
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|   649k|      {
   44|   649k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   649k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   649k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   649k|      else {
  108|   649k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   649k|         using iterator_t = typename ParseInput::iterator_t;
  111|   649k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   649k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   649k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   649k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   649k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   649k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   649k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   649k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   649k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   649k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   649k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   649k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   649k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   649k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   649k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   649k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   649k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   649k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 649k, 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|   649k|            else if constexpr( has_apply0_bool ) {
  153|   649k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   649k|            }
  155|   649k|         }
  156|   649k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 649k, False: 0]
  ------------------
  157|   649k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   649k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   649k|         (void)m( result );
  163|   649k|         return result;
  164|   649k|      }
  165|   649k|   }
_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|   649k|      {
   73|   649k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   649k|         else {
   84|   649k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   649k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   649k|      }
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|   649k|      {
   44|   649k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   649k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   649k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   649k|      else {
  108|   649k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   649k|         using iterator_t = typename ParseInput::iterator_t;
  111|   649k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   649k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   649k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   649k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   649k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   649k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   649k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   649k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   649k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   649k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   649k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   649k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   649k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   649k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   649k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   649k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   649k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   649k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 310, False: 648k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    310|            else if constexpr( has_apply0_bool ) {
  153|    310|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    310|            }
  155|    310|         }
  156|   649k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 310, False: 648k]
  ------------------
  157|    310|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    310|         }
  159|   648k|         else {
  160|   648k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   648k|         }
  162|   649k|         (void)m( result );
  163|   649k|         return result;
  164|   649k|      }
  165|   649k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   649k|      {
   73|   649k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   649k|         else {
   84|   649k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   649k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   649k|      }
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|   649k|      {
   59|   649k|         return Rule::match( in );
   60|   649k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   649k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   649k|      else {
  108|   649k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   649k|         using iterator_t = typename ParseInput::iterator_t;
  111|   649k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   649k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   649k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   649k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   649k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   649k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   649k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   649k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   649k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   649k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   649k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   649k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   649k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   649k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   649k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   649k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   649k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   649k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 647k, 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|   647k|            else if constexpr( has_apply0_bool ) {
  153|   647k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   647k|            }
  155|   647k|         }
  156|   649k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 647k, False: 1.10k]
  ------------------
  157|   647k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   647k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|   649k|         (void)m( result );
  163|   649k|         return result;
  164|   649k|      }
  165|   649k|   }
_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|   649k|      {
   73|   649k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   649k|         else {
   84|   649k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   649k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   649k|      }
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|   649k|      {
   44|   649k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   649k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   649k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   649k|      else {
  108|   649k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   649k|         using iterator_t = typename ParseInput::iterator_t;
  111|   649k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   649k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   649k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   649k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   649k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   649k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   649k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   649k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   649k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   649k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   649k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   649k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   649k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   649k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   649k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   649k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   649k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   649k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 647k, 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|   647k|            else if constexpr( has_apply0_bool ) {
  153|   647k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   647k|            }
  155|   647k|         }
  156|   649k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 647k, False: 1.10k]
  ------------------
  157|   647k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   647k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|   649k|         (void)m( result );
  163|   649k|         return result;
  164|   649k|      }
  165|   649k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   649k|      {
   73|   649k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   649k|         else {
   84|   649k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   649k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   649k|      }
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|   649k|      {
   59|   649k|         return Rule::match( in );
   60|   649k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   647k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   647k|      else {
  108|   647k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   647k|         using iterator_t = typename ParseInput::iterator_t;
  111|   647k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   647k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   647k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   647k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   647k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   647k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   647k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   647k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   647k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   647k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   647k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   647k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   647k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   647k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   647k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   647k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   647k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   647k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 647k, 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|   647k|            else if constexpr( has_apply0_bool ) {
  153|   647k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   647k|            }
  155|   647k|         }
  156|   647k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 647k, False: 0]
  ------------------
  157|   647k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   647k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   647k|         (void)m( result );
  163|   647k|         return result;
  164|   647k|      }
  165|   647k|   }
_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|   647k|      {
   73|   647k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   647k|         else {
   84|   647k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   647k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   647k|      }
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|   647k|      {
   44|   647k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   647k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  27.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.0M|      else {
  108|  27.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 26.3M, False: 647k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3M|            else if constexpr( has_apply0_bool ) {
  153|  26.3M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  26.3M|            }
  155|  26.3M|         }
  156|  27.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 26.3M, False: 647k]
  ------------------
  157|  26.3M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  26.3M|         }
  159|   647k|         else {
  160|   647k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   647k|         }
  162|  27.0M|         (void)m( result );
  163|  27.0M|         return result;
  164|  27.0M|      }
  165|  27.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  27.0M|      {
   73|  27.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|  27.0M|         else {
   84|  27.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.0M|      }
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|  27.0M|      {
   59|  27.0M|         return Rule::match( in );
   60|  27.0M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   647k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   647k|      else {
  108|   647k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   647k|         using iterator_t = typename ParseInput::iterator_t;
  111|   647k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   647k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   647k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   647k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   647k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   647k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   647k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   647k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   647k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   647k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   647k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   647k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   647k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   647k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   647k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   647k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   647k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   647k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 647k, False: 397]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   647k|            else if constexpr( has_apply0_bool ) {
  153|   647k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   647k|            }
  155|   647k|         }
  156|   647k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 647k, False: 397]
  ------------------
  157|   647k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   647k|         }
  159|    397|         else {
  160|    397|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    397|         }
  162|   647k|         (void)m( result );
  163|   647k|         return result;
  164|   647k|      }
  165|   647k|   }
_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|   647k|      {
   73|   647k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   647k|         else {
   84|   647k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   647k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   647k|      }
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|   647k|      {
   44|   647k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   647k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   647k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   647k|      else {
  108|   647k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   647k|         using iterator_t = typename ParseInput::iterator_t;
  111|   647k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   647k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   647k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   647k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   647k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   647k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   647k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   647k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   647k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   647k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   647k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   647k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   647k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   647k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   647k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   647k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   647k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   647k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.3k, False: 603k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  44.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.3k|            }
  155|  44.3k|         }
  156|   647k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.3k, False: 603k]
  ------------------
  157|  44.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.3k|         }
  159|   603k|         else {
  160|   603k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   603k|         }
  162|   647k|         (void)m( result );
  163|   647k|         return result;
  164|   647k|      }
  165|   647k|   }
_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|   647k|      {
   73|   647k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   647k|         else {
   84|   647k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   647k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   647k|      }
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|   647k|      {
   44|   647k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   647k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   647k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   647k|      else {
  108|   647k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   647k|         using iterator_t = typename ParseInput::iterator_t;
  111|   647k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   647k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   647k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   647k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   647k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   647k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   647k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   647k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   647k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   647k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   647k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   647k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   647k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   647k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   647k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   647k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   647k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   647k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.7k, False: 603k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.7k|            else if constexpr( has_apply0_bool ) {
  153|  44.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.7k|            }
  155|  44.7k|         }
  156|   647k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.7k, False: 603k]
  ------------------
  157|  44.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.7k|         }
  159|   603k|         else {
  160|   603k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   603k|         }
  162|   647k|         (void)m( result );
  163|   647k|         return result;
  164|   647k|      }
  165|   647k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   647k|      {
   73|   647k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   647k|         else {
   84|   647k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   647k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   647k|      }
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|   647k|      {
   59|   647k|         return Rule::match( in );
   60|   647k|      }
_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|  44.7k|   {
  104|  44.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  44.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|  44.7k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.7k|      {
   44|  44.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.7k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.7k|      else {
  108|  44.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.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|  44.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|  44.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|  44.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|  44.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.7k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  44.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.3k, False: 397]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  44.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.3k|            }
  155|  44.3k|         }
  156|  44.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.3k, False: 397]
  ------------------
  157|  44.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.3k|         }
  159|    397|         else {
  160|    397|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    397|         }
  162|  44.7k|         (void)m( result );
  163|  44.7k|         return result;
  164|  44.7k|      }
  165|  44.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7k|      {
   73|  44.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|  44.7k|         else {
   84|  44.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  44.7k|      {
   44|  44.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  48.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.3M|      else {
  108|  48.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.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|  48.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|  48.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|  48.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|  48.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|  48.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|  48.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.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|  48.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.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|  48.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.3k, False: 48.2M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.3k|            else if constexpr( has_apply0_bool ) {
  153|  44.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.3k|            }
  155|  44.3k|         }
  156|  48.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.3k, False: 48.2M]
  ------------------
  157|  44.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.3k|         }
  159|  48.2M|         else {
  160|  48.2M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  48.2M|         }
  162|  48.3M|         (void)m( result );
  163|  48.3M|         return result;
  164|  48.3M|      }
  165|  48.3M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  48.3M|      {
   73|  48.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|  48.3M|         else {
   84|  48.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.3M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  48.3M|      {
   59|  48.3M|         return Rule::match( in );
   60|  48.3M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.2M|      else {
  108|  48.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.2M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.2M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.2M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.2M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.2M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.2M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.2M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.2M, False: 397]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.2M|            else if constexpr( has_apply0_bool ) {
  153|  48.2M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.2M|            }
  155|  48.2M|         }
  156|  48.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.2M, False: 397]
  ------------------
  157|  48.2M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.2M|         }
  159|    397|         else {
  160|    397|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    397|         }
  162|  48.2M|         (void)m( result );
  163|  48.2M|         return result;
  164|  48.2M|      }
  165|  48.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  48.2M|      {
   73|  48.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.2M|         else {
   84|  48.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.2M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.2M|      {
   44|  48.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.2M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.2M|      else {
  108|  48.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.2M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.2M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.2M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.2M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.2M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.2M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.2M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 148k, False: 48.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   148k|            else if constexpr( has_apply0_bool ) {
  153|   148k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   148k|            }
  155|   148k|         }
  156|  48.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 148k, False: 48.1M]
  ------------------
  157|   148k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   148k|         }
  159|  48.1M|         else {
  160|  48.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  48.1M|         }
  162|  48.2M|         (void)m( result );
  163|  48.2M|         return result;
  164|  48.2M|      }
  165|  48.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  48.2M|      {
   73|  48.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.2M|         else {
   84|  48.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.2M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.2M|      {
   44|  48.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.2M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  48.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.2M|      else {
  108|  48.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.2M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.2M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.2M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.2M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.2M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.2M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.2M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 148k, False: 48.1M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   148k|            else if constexpr( has_apply0_bool ) {
  153|   148k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   148k|            }
  155|   148k|         }
  156|  48.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 148k, False: 48.1M]
  ------------------
  157|   148k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   148k|         }
  159|  48.1M|         else {
  160|  48.1M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  48.1M|         }
  162|  48.2M|         (void)m( result );
  163|  48.2M|         return result;
  164|  48.2M|      }
  165|  48.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  48.2M|      {
   73|  48.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.2M|         else {
   84|  48.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.2M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  48.2M|      {
   59|  48.2M|         return Rule::match( in );
   60|  48.2M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   148k|   {
  104|   148k|      if constexpr( !Control< Rule >::enable ) {
  105|   148k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   148k|   }
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|   148k|      {
   44|   148k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   148k|      }
_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|   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: 148k, False: 119]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   148k|            else if constexpr( has_apply0_bool ) {
  153|   148k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   148k|            }
  155|   148k|         }
  156|   148k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 148k, False: 119]
  ------------------
  157|   148k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   148k|         }
  159|    119|         else {
  160|    119|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    119|         }
  162|   148k|         (void)m( result );
  163|   148k|         return result;
  164|   148k|      }
  165|   148k|   }
_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|   148k|      {
   73|   148k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   148k|         else {
   84|   148k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   148k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   148k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   148k|      {
   44|   148k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   148k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_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: 38.3k, False: 110k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|   148k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 110k]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|   110k|         else {
  160|   110k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   110k|         }
  162|   148k|         (void)m( result );
  163|   148k|         return result;
  164|   148k|      }
  165|   148k|   }
_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|   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_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|   148k|      {
   44|   148k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   148k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 38.3k, False: 110k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|   148k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 110k]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|   110k|         else {
  160|   110k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   110k|         }
  162|   148k|         (void)m( result );
  163|   148k|         return result;
  164|   148k|      }
  165|   148k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   148k|      {
   73|   148k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   148k|         else {
   84|   148k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   148k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   148k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   148k|      {
   59|   148k|         return Rule::match( in );
   60|   148k|      }
_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.3k|   {
  104|  38.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.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|  38.3k|   }
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.3k|      {
   44|  38.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.3k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.3k|      else {
  108|  38.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.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|  38.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|  38.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|  38.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|  38.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.3k, 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|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|  38.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 51]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|  38.3k|         (void)m( result );
  163|  38.3k|         return result;
  164|  38.3k|      }
  165|  38.3k|   }
_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.3k|      {
   73|  38.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|  38.3k|         else {
   84|  38.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.3k|      {
   44|  38.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  76.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  76.7k|      else {
  108|  76.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  76.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  76.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|  76.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|  76.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|  76.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|  76.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|  76.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|  76.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  76.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  76.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  76.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|  76.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  76.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  76.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|  76.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  76.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  76.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  76.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  76.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 76.6k, 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|  76.6k|            else if constexpr( has_apply0_bool ) {
  153|  76.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  76.6k|            }
  155|  76.6k|         }
  156|  76.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 76.6k, False: 51]
  ------------------
  157|  76.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  76.6k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|  76.7k|         (void)m( result );
  163|  76.7k|         return result;
  164|  76.7k|      }
  165|  76.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  76.7k|      {
   73|  76.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|  76.7k|         else {
   84|  76.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  76.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  76.7k|      }
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|  76.7k|      {
   59|  76.7k|         return Rule::match( in );
   60|  76.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   110k|      else {
  108|   110k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   110k|         using iterator_t = typename ParseInput::iterator_t;
  111|   110k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   110k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   110k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   110k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   110k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   110k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   110k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   110k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   110k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   110k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   110k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   110k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   110k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   110k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   110k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   110k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   110k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   110k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.1k, False: 81.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|  29.1k|            else if constexpr( has_apply0_bool ) {
  153|  29.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.1k|            }
  155|  29.1k|         }
  156|   110k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.1k, False: 81.2k]
  ------------------
  157|  29.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.1k|         }
  159|  81.2k|         else {
  160|  81.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  81.2k|         }
  162|   110k|         (void)m( result );
  163|   110k|         return result;
  164|   110k|      }
  165|   110k|   }
_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|   110k|      {
   73|   110k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   110k|         else {
   84|   110k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   110k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   110k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   110k|      {
   44|   110k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   110k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   145k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   145k|      else {
  108|   145k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   145k|         using iterator_t = typename ParseInput::iterator_t;
  111|   145k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   145k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   145k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   145k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   145k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   145k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   145k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   145k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   145k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   145k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   145k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   145k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   145k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   145k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   145k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   145k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   145k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   145k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.2k, False: 107k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   145k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.2k, False: 107k]
  ------------------
  157|  37.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.2k|         }
  159|   107k|         else {
  160|   107k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   107k|         }
  162|   145k|         (void)m( result );
  163|   145k|         return result;
  164|   145k|      }
  165|   145k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   145k|      {
   73|   145k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   145k|         else {
   84|   145k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   145k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   145k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   145k|      {
   59|   145k|         return Rule::match( in );
   60|   145k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  29.1k|   {
  104|  29.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  29.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.1k|      else {
  108|  29.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.1k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  29.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.1k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.1k|            else if constexpr( has_apply0_bool ) {
  153|  29.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.1k|            }
  155|  29.1k|         }
  156|  29.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.1k, False: 0]
  ------------------
  157|  29.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  29.1k|         (void)m( result );
  163|  29.1k|         return result;
  164|  29.1k|      }
  165|  29.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  29.1k|      {
   73|  29.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.1k|         else {
   84|  29.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  81.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  81.2k|      else {
  108|  81.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  81.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  81.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|  81.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|  81.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|  81.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|  81.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|  81.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|  81.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  81.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  81.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  81.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|  81.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  81.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  81.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|  81.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  81.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  81.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  81.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  81.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 80.9k, False: 342]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  80.9k|            else if constexpr( has_apply0_bool ) {
  153|  80.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  80.9k|            }
  155|  80.9k|         }
  156|  81.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 80.9k, False: 342]
  ------------------
  157|  80.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  80.9k|         }
  159|    342|         else {
  160|    342|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    342|         }
  162|  81.2k|         (void)m( result );
  163|  81.2k|         return result;
  164|  81.2k|      }
  165|  81.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  81.2k|      {
   73|  81.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|  81.2k|         else {
   84|  81.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  81.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  81.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  81.2k|      {
   59|  81.2k|         return Rule::match( in );
   60|  81.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    342|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    342|      else {
  108|    342|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    342|         using iterator_t = typename ParseInput::iterator_t;
  111|    342|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    342|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    342|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    342|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    342|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    342|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    342|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    342|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    342|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    342|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    342|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    342|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    342|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    342|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    342|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    342|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    342|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    342|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 274, False: 68]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    274|            else if constexpr( has_apply0_bool ) {
  153|    274|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    274|            }
  155|    274|         }
  156|    342|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 274, False: 68]
  ------------------
  157|    274|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    274|         }
  159|     68|         else {
  160|     68|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     68|         }
  162|    342|         (void)m( result );
  163|    342|         return result;
  164|    342|      }
  165|    342|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    342|      {
   73|    342|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    342|         else {
   84|    342|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    342|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    342|      }
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|    342|      {
   59|    342|         return Rule::match( in );
   60|    342|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  48.1M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.1M|      else {
  108|  48.1M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.1M|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.1M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.1M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.1M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.1M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.1M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.1M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.1M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.1M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.1M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.1M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.1M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.1M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.1M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  48.1M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.1M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.1M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.1M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.1M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.1M, False: 278]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.1M|            else if constexpr( has_apply0_bool ) {
  153|  48.1M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.1M|            }
  155|  48.1M|         }
  156|  48.1M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.1M, False: 278]
  ------------------
  157|  48.1M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.1M|         }
  159|    278|         else {
  160|    278|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    278|         }
  162|  48.1M|         (void)m( result );
  163|  48.1M|         return result;
  164|  48.1M|      }
  165|  48.1M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  48.1M|      {
   73|  48.1M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.1M|         else {
   84|  48.1M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.1M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.1M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  48.1M|      {
   59|  48.1M|         return Rule::match( in );
   60|  48.1M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  14.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.0k|      else {
  108|  14.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  14.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  14.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|  14.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|  14.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|  14.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|  14.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  14.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.33k, False: 10.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.33k|            else if constexpr( has_apply0_bool ) {
  153|  3.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.33k|            }
  155|  3.33k|         }
  156|  14.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.33k, False: 10.7k]
  ------------------
  157|  3.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.33k|         }
  159|  10.7k|         else {
  160|  10.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.7k|         }
  162|  14.0k|         (void)m( result );
  163|  14.0k|         return result;
  164|  14.0k|      }
  165|  14.0k|   }
_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|  14.0k|      {
   73|  14.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|  14.0k|         else {
   84|  14.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  14.0k|      {
   44|  14.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.0k|      }
_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|  14.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.0k|      else {
  108|  14.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  14.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  14.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|  14.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|  14.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|  14.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|  14.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  14.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.33k, False: 10.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.33k|            else if constexpr( has_apply0_bool ) {
  153|  3.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.33k|            }
  155|  3.33k|         }
  156|  14.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.33k, False: 10.7k]
  ------------------
  157|  3.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.33k|         }
  159|  10.7k|         else {
  160|  10.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.7k|         }
  162|  14.0k|         (void)m( result );
  163|  14.0k|         return result;
  164|  14.0k|      }
  165|  14.0k|   }
_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|  14.0k|      {
   73|  14.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|  14.0k|         else {
   84|  14.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  14.0k|      {
   44|  14.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  14.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.0k|      else {
  108|  14.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  14.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  14.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|  14.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|  14.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|  14.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|  14.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  14.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.05k, False: 10.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|  4.05k|            else if constexpr( has_apply0_bool ) {
  153|  4.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.05k|            }
  155|  4.05k|         }
  156|  14.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.05k, False: 10.0k]
  ------------------
  157|  4.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.05k|         }
  159|  10.0k|         else {
  160|  10.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.0k|         }
  162|  14.0k|         (void)m( result );
  163|  14.0k|         return result;
  164|  14.0k|      }
  165|  14.0k|   }
_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|  14.0k|      {
   73|  14.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|  14.0k|         else {
   84|  14.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  14.0k|      {
   59|  14.0k|         return Rule::match( in );
   60|  14.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.83k|      else {
  108|  9.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.03k, False: 1.80k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.03k|            else if constexpr( has_apply0_bool ) {
  153|  8.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.03k|            }
  155|  8.03k|         }
  156|  9.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.03k, False: 1.80k]
  ------------------
  157|  8.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.03k|         }
  159|  1.80k|         else {
  160|  1.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.80k|         }
  162|  9.83k|         (void)m( result );
  163|  9.83k|         return result;
  164|  9.83k|      }
  165|  9.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  9.83k|      {
   73|  9.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.83k|         else {
   84|  9.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.83k|      {
   44|  9.83k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.83k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.83k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.83k|      else {
  108|  9.83k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.83k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.83k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.83k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.83k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.83k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.83k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.83k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.83k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.83k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.83k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.83k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.83k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.83k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.83k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.83k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.83k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.83k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.83k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.83k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.03k, False: 1.80k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.03k|            else if constexpr( has_apply0_bool ) {
  153|  8.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.03k|            }
  155|  8.03k|         }
  156|  9.83k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.03k, False: 1.80k]
  ------------------
  157|  8.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.03k|         }
  159|  1.80k|         else {
  160|  1.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.80k|         }
  162|  9.83k|         (void)m( result );
  163|  9.83k|         return result;
  164|  9.83k|      }
  165|  9.83k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.83k|      {
   73|  9.83k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.83k|         else {
   84|  9.83k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.83k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.83k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.83k|      {
   59|  9.83k|         return Rule::match( in );
   60|  9.83k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.1k|      else {
  108|  16.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.58k, False: 12.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.58k|            else if constexpr( has_apply0_bool ) {
  153|  3.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.58k|            }
  155|  3.58k|         }
  156|  16.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.58k, False: 12.5k]
  ------------------
  157|  3.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.58k|         }
  159|  12.5k|         else {
  160|  12.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.5k|         }
  162|  16.1k|         (void)m( result );
  163|  16.1k|         return result;
  164|  16.1k|      }
  165|  16.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|  16.1k|      {
   73|  16.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|  16.1k|         else {
   84|  16.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.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|  16.1k|      {
   59|  16.1k|         return Rule::match( in );
   60|  16.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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.33k, False: 701]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.33k|            else if constexpr( has_apply0_bool ) {
  153|  3.33k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.33k|            }
  155|  3.33k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.33k, False: 701]
  ------------------
  157|  3.33k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.33k|         }
  159|    701|         else {
  160|    701|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    701|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.07k, 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.07k|            else if constexpr( has_apply0_bool ) {
  153|  2.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.07k|            }
  155|  2.07k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.07k, False: 1.95k]
  ------------------
  157|  2.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.07k|         }
  159|  1.95k|         else {
  160|  1.95k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.95k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.03k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.03k|            else if constexpr( has_apply0_bool ) {
  153|  4.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.03k|            }
  155|  4.03k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.03k, False: 0]
  ------------------
  157|  4.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.03k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|  4.03k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.03k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.03k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.03k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.03k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.39k, False: 2.63k]
  ------------------
  143|  1.39k|            if constexpr( has_apply_void ) {
  144|  1.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.39k|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.39k, False: 2.63k]
  ------------------
  157|  1.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.39k|         }
  159|  2.63k|         else {
  160|  2.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.63k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.03k|      {
   44|  4.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 207, False: 3.82k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    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|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 207, False: 3.82k]
  ------------------
  157|    207|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    207|         }
  159|  3.82k|         else {
  160|  3.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.82k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.03k|      {
   59|  4.03k|         return Rule::match( in );
   60|  4.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.82k|      else {
  108|  3.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.82k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 248, False: 3.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|    248|            else if constexpr( has_apply0_bool ) {
  153|    248|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    248|            }
  155|    248|         }
  156|  3.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 248, False: 3.57k]
  ------------------
  157|    248|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    248|         }
  159|  3.57k|         else {
  160|  3.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.57k|         }
  162|  3.82k|         (void)m( result );
  163|  3.82k|         return result;
  164|  3.82k|      }
  165|  3.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.82k|      {
   73|  3.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.82k|         else {
   84|  3.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.82k|      {
   59|  3.82k|         return Rule::match( in );
   60|  3.82k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.57k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.57k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.57k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.57k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.57k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, 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|    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.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 3.38k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  3.38k|         else {
  160|  3.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.38k|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.57k|      {
   59|  3.57k|         return Rule::match( in );
   60|  3.57k|      }
_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.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: 198, 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|    198|            else if constexpr( has_apply0_bool ) {
  153|    198|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    198|            }
  155|    198|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 198, False: 3.18k]
  ------------------
  157|    198|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    198|         }
  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_13label_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_13label_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_13label_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: 294, False: 2.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    294|            else if constexpr( has_apply0_bool ) {
  153|    294|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    294|            }
  155|    294|         }
  156|  3.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 294, False: 2.88k]
  ------------------
  157|    294|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    294|         }
  159|  2.88k|         else {
  160|  2.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.88k|         }
  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_13label_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_13label_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_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88k|      else {
  108|  2.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.88k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 251, False: 2.63k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    251|            else if constexpr( has_apply0_bool ) {
  153|    251|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    251|            }
  155|    251|         }
  156|  2.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 251, False: 2.63k]
  ------------------
  157|    251|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    251|         }
  159|  2.63k|         else {
  160|  2.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.63k|         }
  162|  2.88k|         (void)m( result );
  163|  2.88k|         return result;
  164|  2.88k|      }
  165|  2.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.88k|      {
   73|  2.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.88k|         else {
   84|  2.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.88k|      {
   59|  2.88k|         return Rule::match( in );
   60|  2.88k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.03k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.03k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.03k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.03k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.28k, 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.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|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.28k, False: 1.74k]
  ------------------
  157|  2.28k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.28k|         }
  159|  1.74k|         else {
  160|  1.74k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.74k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.03k|      {
   59|  4.03k|         return Rule::match( in );
   60|  4.03k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.48k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.48k|      else {
  108|  4.48k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.48k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.48k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.48k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.48k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.48k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.48k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.48k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.48k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.48k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.48k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.48k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.48k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.48k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.48k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.48k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.48k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.48k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.48k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.48k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.48k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.48k|            else if constexpr( has_apply0_bool ) {
  153|  4.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.48k|            }
  155|  4.48k|         }
  156|  4.48k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.48k, False: 0]
  ------------------
  157|  4.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.48k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.48k|         (void)m( result );
  163|  4.48k|         return result;
  164|  4.48k|      }
  165|  4.48k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.48k|      {
   73|  4.48k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.48k|         else {
   84|  4.48k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.48k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.48k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.48k|      {
   44|  4.48k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.48k|      }
_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.28k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.28k|      else {
  108|  2.28k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.28k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.28k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.28k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.28k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.28k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.28k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.28k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.28k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.28k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.28k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.28k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.28k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.28k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.28k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.28k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.28k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.28k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.28k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.28k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.19k, False: 90]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.28k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.19k, False: 90]
  ------------------
  157|  2.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.19k|         }
  159|     90|         else {
  160|     90|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     90|         }
  162|  2.28k|         (void)m( result );
  163|  2.28k|         return result;
  164|  2.28k|      }
  165|  2.28k|   }
_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.28k|      {
   73|  2.28k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.28k|         else {
   84|  2.28k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.28k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.28k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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.28k|      {
   44|  2.28k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.28k|      }
_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.21k|   {
  104|  2.21k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.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|  2.21k|   }
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.21k|      {
   44|  2.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.21k|      }
_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.39k|   {
  104|  4.39k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.39k|   }
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.39k|      {
   44|  4.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.39k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.19k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.19k|      else {
  108|  2.19k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.19k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.19k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.19k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.19k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.19k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.19k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.19k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.19k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.19k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.19k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.19k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.19k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.19k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.19k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.19k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.19k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.19k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.19k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.19k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.07k, False: 119]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.07k|            else if constexpr( has_apply0_bool ) {
  153|  2.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.07k|            }
  155|  2.07k|         }
  156|  2.19k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.07k, False: 119]
  ------------------
  157|  2.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.07k|         }
  159|    119|         else {
  160|    119|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    119|         }
  162|  2.19k|         (void)m( result );
  163|  2.19k|         return result;
  164|  2.19k|      }
  165|  2.19k|   }
_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.19k|      {
   73|  2.19k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.19k|         else {
   84|  2.19k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.19k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.19k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.19k|      {
   59|  2.19k|         return Rule::match( in );
   60|  2.19k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.87k|      else {
  108|  6.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.87k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.87k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.87k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.87k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.87k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.87k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.87k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.87k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.87k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.87k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.69k, False: 1.17k]
  ------------------
  143|  5.69k|            if constexpr( has_apply_void ) {
  144|  5.69k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  5.69k|         }
  156|  6.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.64k, False: 1.22k]
  ------------------
  157|  5.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.64k|         }
  159|  1.22k|         else {
  160|  1.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.22k|         }
  162|  6.87k|         (void)m( result );
  163|  6.87k|         return result;
  164|  6.87k|      }
  165|  6.87k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.87k|      {
   73|  6.87k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.87k|         else {
   84|  6.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.87k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.87k|      {
   44|  6.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.87k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.87k|      else {
  108|  6.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.87k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.87k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.87k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.87k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.87k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.87k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.87k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.87k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.00k, False: 866]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.00k|            else if constexpr( has_apply0_bool ) {
  153|  6.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.00k|            }
  155|  6.00k|         }
  156|  6.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.00k, False: 866]
  ------------------
  157|  6.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.00k|         }
  159|    866|         else {
  160|    866|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    866|         }
  162|  6.87k|         (void)m( result );
  163|  6.87k|         return result;
  164|  6.87k|      }
  165|  6.87k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.87k|      {
   73|  6.87k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.87k|         else {
   84|  6.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.87k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.87k|      {
   59|  6.87k|         return Rule::match( in );
   60|  6.87k|      }
_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.00k|   {
  104|  6.00k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.00k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), 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.00k|   }
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.00k|      {
   44|  6.00k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.00k|      }
_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.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.00k|      else {
  108|  6.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.00k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.00k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.00k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.00k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.00k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.00k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.00k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.00k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.69k, False: 311]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.69k|            else if constexpr( has_apply0_bool ) {
  153|  5.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.69k|            }
  155|  5.69k|         }
  156|  6.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.69k, False: 311]
  ------------------
  157|  5.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.69k|         }
  159|    311|         else {
  160|    311|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    311|         }
  162|  6.00k|         (void)m( result );
  163|  6.00k|         return result;
  164|  6.00k|      }
  165|  6.00k|   }
_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.00k|      {
   73|  6.00k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.00k|         else {
   84|  6.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.00k|      }
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.00k|      {
   44|  6.00k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.00k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.90M|      else {
  108|  9.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.69k, False: 9.90M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.69k|            else if constexpr( has_apply0_bool ) {
  153|  5.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.69k|            }
  155|  5.69k|         }
  156|  9.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.69k, False: 9.90M]
  ------------------
  157|  5.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.69k|         }
  159|  9.90M|         else {
  160|  9.90M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.90M|         }
  162|  9.90M|         (void)m( result );
  163|  9.90M|         return result;
  164|  9.90M|      }
  165|  9.90M|   }
_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.90M|      {
   73|  9.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.90M|         else {
   84|  9.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.90M|      }
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.90M|      {
   59|  9.90M|         return Rule::match( in );
   60|  9.90M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.90M|      else {
  108|  9.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.90M, False: 311]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.90M|            else if constexpr( has_apply0_bool ) {
  153|  9.90M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.90M|            }
  155|  9.90M|         }
  156|  9.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.90M, False: 311]
  ------------------
  157|  9.90M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.90M|         }
  159|    311|         else {
  160|    311|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    311|         }
  162|  9.90M|         (void)m( result );
  163|  9.90M|         return result;
  164|  9.90M|      }
  165|  9.90M|   }
_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.90M|      {
   73|  9.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.90M|         else {
   84|  9.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.90M|      }
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.90M|      {
   44|  9.90M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.90M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.90M|      else {
  108|  9.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 179k, False: 9.72M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   179k|            else if constexpr( has_apply0_bool ) {
  153|   179k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   179k|            }
  155|   179k|         }
  156|  9.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 179k, False: 9.72M]
  ------------------
  157|   179k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   179k|         }
  159|  9.72M|         else {
  160|  9.72M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.72M|         }
  162|  9.90M|         (void)m( result );
  163|  9.90M|         return result;
  164|  9.90M|      }
  165|  9.90M|   }
_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.90M|      {
   73|  9.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.90M|         else {
   84|  9.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.90M|      }
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.90M|      {
   44|  9.90M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.90M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.90M|      else {
  108|  9.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.90M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 179k, False: 9.72M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   179k|            else if constexpr( has_apply0_bool ) {
  153|   179k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   179k|            }
  155|   179k|         }
  156|  9.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 179k, False: 9.72M]
  ------------------
  157|   179k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   179k|         }
  159|  9.72M|         else {
  160|  9.72M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.72M|         }
  162|  9.90M|         (void)m( result );
  163|  9.90M|         return result;
  164|  9.90M|      }
  165|  9.90M|   }
_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.90M|      {
   73|  9.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.90M|         else {
   84|  9.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.90M|      }
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.90M|      {
   59|  9.90M|         return Rule::match( in );
   60|  9.90M|      }
_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|   179k|   {
  104|   179k|      if constexpr( !Control< Rule >::enable ) {
  105|   179k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   179k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_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|   179k|      {
   44|   179k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   179k|      }
_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|   179k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   179k|      else {
  108|   179k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   179k|         using iterator_t = typename ParseInput::iterator_t;
  111|   179k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   179k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   179k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   179k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   179k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   179k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   179k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   179k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   179k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   179k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   179k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   179k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   179k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   179k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   179k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   179k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   179k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   179k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 179k, False: 109]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   179k|            else if constexpr( has_apply0_bool ) {
  153|   179k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   179k|            }
  155|   179k|         }
  156|   179k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 179k, False: 109]
  ------------------
  157|   179k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   179k|         }
  159|    109|         else {
  160|    109|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    109|         }
  162|   179k|         (void)m( result );
  163|   179k|         return result;
  164|   179k|      }
  165|   179k|   }
_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|   179k|      {
   73|   179k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   179k|         else {
   84|   179k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   179k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   179k|      }
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|   179k|      {
   44|   179k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   179k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   179k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   179k|      else {
  108|   179k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   179k|         using iterator_t = typename ParseInput::iterator_t;
  111|   179k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   179k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   179k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   179k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   179k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   179k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   179k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   179k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   179k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   179k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   179k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   179k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   179k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   179k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   179k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   179k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   179k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   179k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 54.0k, False: 125k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  54.0k|            else if constexpr( has_apply0_bool ) {
  153|  54.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  54.0k|            }
  155|  54.0k|         }
  156|   179k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 54.0k, False: 125k]
  ------------------
  157|  54.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  54.0k|         }
  159|   125k|         else {
  160|   125k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   125k|         }
  162|   179k|         (void)m( result );
  163|   179k|         return result;
  164|   179k|      }
  165|   179k|   }
_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|   179k|      {
   73|   179k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   179k|         else {
   84|   179k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   179k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   179k|      }
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|   179k|      {
   44|   179k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   179k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   179k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   179k|      else {
  108|   179k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   179k|         using iterator_t = typename ParseInput::iterator_t;
  111|   179k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   179k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   179k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   179k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   179k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   179k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   179k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   179k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   179k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   179k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   179k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   179k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   179k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   179k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   179k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   179k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   179k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   179k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 54.0k, False: 125k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  54.0k|            else if constexpr( has_apply0_bool ) {
  153|  54.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  54.0k|            }
  155|  54.0k|         }
  156|   179k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 54.0k, False: 125k]
  ------------------
  157|  54.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  54.0k|         }
  159|   125k|         else {
  160|   125k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   125k|         }
  162|   179k|         (void)m( result );
  163|   179k|         return result;
  164|   179k|      }
  165|   179k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   179k|      {
   73|   179k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   179k|         else {
   84|   179k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   179k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   179k|      }
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|   179k|      {
   59|   179k|         return Rule::match( in );
   60|   179k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  54.0k|   {
  104|  54.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  54.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|  54.0k|   }
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|  54.0k|      {
   44|  54.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  54.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  54.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  54.0k|      else {
  108|  54.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  54.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  54.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|  54.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|  54.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|  54.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|  54.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|  54.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|  54.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  54.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  54.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  54.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|  54.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  54.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  54.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|  54.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  54.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  54.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  54.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  54.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 54.0k, 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|  54.0k|            else if constexpr( has_apply0_bool ) {
  153|  54.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  54.0k|            }
  155|  54.0k|         }
  156|  54.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 54.0k, False: 39]
  ------------------
  157|  54.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  54.0k|         }
  159|     39|         else {
  160|     39|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     39|         }
  162|  54.0k|         (void)m( result );
  163|  54.0k|         return result;
  164|  54.0k|      }
  165|  54.0k|   }
_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|  54.0k|      {
   73|  54.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|  54.0k|         else {
   84|  54.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  54.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  54.0k|      }
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|  54.0k|      {
   44|  54.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  54.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   108k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   108k|      else {
  108|   108k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   108k|         using iterator_t = typename ParseInput::iterator_t;
  111|   108k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   108k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   108k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   108k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   108k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   108k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   108k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   108k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   108k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   108k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   108k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   108k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   108k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   108k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   108k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   108k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   108k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   108k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 108k, 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|   108k|            else if constexpr( has_apply0_bool ) {
  153|   108k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   108k|            }
  155|   108k|         }
  156|   108k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 108k, False: 39]
  ------------------
  157|   108k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   108k|         }
  159|     39|         else {
  160|     39|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     39|         }
  162|   108k|         (void)m( result );
  163|   108k|         return result;
  164|   108k|      }
  165|   108k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   108k|      {
   73|   108k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   108k|         else {
   84|   108k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   108k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   108k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   108k|      {
   59|   108k|         return Rule::match( in );
   60|   108k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   125k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   125k|      else {
  108|   125k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   125k|         using iterator_t = typename ParseInput::iterator_t;
  111|   125k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   125k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   125k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   125k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   125k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   125k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   125k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   125k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   125k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   125k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   125k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   125k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   125k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   125k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   125k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   125k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   125k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   125k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 81.1k, False: 44.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|  81.1k|            else if constexpr( has_apply0_bool ) {
  153|  81.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  81.1k|            }
  155|  81.1k|         }
  156|   125k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 81.1k, False: 44.6k]
  ------------------
  157|  81.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  81.1k|         }
  159|  44.6k|         else {
  160|  44.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.6k|         }
  162|   125k|         (void)m( result );
  163|   125k|         return result;
  164|   125k|      }
  165|   125k|   }
_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|   125k|      {
   73|   125k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   125k|         else {
   84|   125k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   125k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   125k|      }
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|   125k|      {
   44|   125k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   125k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   215k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   215k|      else {
  108|   215k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   215k|         using iterator_t = typename ParseInput::iterator_t;
  111|   215k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   215k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   215k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   215k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   215k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   215k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   215k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   215k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   215k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   215k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   215k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   215k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   215k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   215k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   215k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   215k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   215k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   215k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 95.7k, False: 119k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  95.7k|            else if constexpr( has_apply0_bool ) {
  153|  95.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  95.7k|            }
  155|  95.7k|         }
  156|   215k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 95.7k, False: 119k]
  ------------------
  157|  95.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  95.7k|         }
  159|   119k|         else {
  160|   119k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   119k|         }
  162|   215k|         (void)m( result );
  163|   215k|         return result;
  164|   215k|      }
  165|   215k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   215k|      {
   73|   215k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   215k|         else {
   84|   215k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   215k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   215k|      }
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|   215k|      {
   59|   215k|         return Rule::match( in );
   60|   215k|      }
_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|  81.1k|   {
  104|  81.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  81.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|  81.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  81.1k|      {
   44|  81.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  81.1k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  81.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  81.1k|      else {
  108|  81.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  81.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  81.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|  81.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|  81.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|  81.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|  81.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|  81.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|  81.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  81.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  81.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  81.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|  81.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  81.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  81.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|  81.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  81.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  81.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  81.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  81.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 81.1k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  81.1k|            else if constexpr( has_apply0_bool ) {
  153|  81.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  81.1k|            }
  155|  81.1k|         }
  156|  81.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 81.1k, False: 0]
  ------------------
  157|  81.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  81.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  81.1k|         (void)m( result );
  163|  81.1k|         return result;
  164|  81.1k|      }
  165|  81.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  81.1k|      {
   73|  81.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|  81.1k|         else {
   84|  81.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  81.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  81.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  81.1k|      {
   44|  81.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  81.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.6k|      else {
  108|  44.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.0k, False: 1.63k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  43.0k|            else if constexpr( has_apply0_bool ) {
  153|  43.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.0k|            }
  155|  43.0k|         }
  156|  44.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.0k, False: 1.63k]
  ------------------
  157|  43.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.0k|         }
  159|  1.63k|         else {
  160|  1.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.63k|         }
  162|  44.6k|         (void)m( result );
  163|  44.6k|         return result;
  164|  44.6k|      }
  165|  44.6k|   }
_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|  44.6k|      {
   73|  44.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|  44.6k|         else {
   84|  44.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.6k|      }
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|  44.6k|      {
   59|  44.6k|         return Rule::match( in );
   60|  44.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.63k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.63k|      else {
  108|  1.63k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.63k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.63k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.63k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.63k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.63k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.63k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.63k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.63k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.63k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.63k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.63k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.63k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.63k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.63k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.63k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.63k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.63k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.63k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.63k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.56k, False: 70]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.56k|            else if constexpr( has_apply0_bool ) {
  153|  1.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.56k|            }
  155|  1.56k|         }
  156|  1.63k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.56k, False: 70]
  ------------------
  157|  1.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.56k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  1.63k|         (void)m( result );
  163|  1.63k|         return result;
  164|  1.63k|      }
  165|  1.63k|   }
_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.63k|      {
   73|  1.63k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.63k|         else {
   84|  1.63k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.63k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.63k|      }
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.63k|      {
   59|  1.63k|         return Rule::match( in );
   60|  1.63k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.72M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.72M|      else {
  108|  9.72M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.72M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.72M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.72M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.72M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.72M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.72M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.72M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.72M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.72M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.72M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.72M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.72M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.72M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.72M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.72M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.72M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.72M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.72M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.72M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.72M, False: 202]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.72M|            else if constexpr( has_apply0_bool ) {
  153|  9.72M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.72M|            }
  155|  9.72M|         }
  156|  9.72M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.72M, False: 202]
  ------------------
  157|  9.72M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.72M|         }
  159|    202|         else {
  160|    202|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    202|         }
  162|  9.72M|         (void)m( result );
  163|  9.72M|         return result;
  164|  9.72M|      }
  165|  9.72M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.72M|      {
   73|  9.72M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.72M|         else {
   84|  9.72M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.72M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.72M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.72M|      {
   59|  9.72M|         return Rule::match( in );
   60|  9.72M|      }
_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|  29.8k|   {
  104|  29.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.8k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_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|  29.8k|      {
   44|  29.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.8k|      }
_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|  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_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|  32.9k|      {
   44|  32.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.9k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  38.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.8k|      else {
  108|  38.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.8k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.8k|            else if constexpr( has_apply0_bool ) {
  153|  38.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.8k|            }
  155|  38.8k|         }
  156|  38.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.8k, False: 0]
  ------------------
  157|  38.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.8k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  38.8k|         (void)m( result );
  163|  38.8k|         return result;
  164|  38.8k|      }
  165|  38.8k|   }
_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|  38.8k|      {
   73|  38.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|  38.8k|         else {
   84|  38.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.8k|      }
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|  38.8k|      {
   44|  38.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.8k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  39.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.0k|      else {
  108|  39.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.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|  39.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|  39.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|  39.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|  39.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|  39.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|  39.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.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|  39.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.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|  39.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.4k, False: 4.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|  34.4k|            else if constexpr( has_apply0_bool ) {
  153|  34.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.4k|            }
  155|  34.4k|         }
  156|  39.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.4k, False: 4.57k]
  ------------------
  157|  34.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.4k|         }
  159|  4.57k|         else {
  160|  4.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.57k|         }
  162|  39.0k|         (void)m( result );
  163|  39.0k|         return result;
  164|  39.0k|      }
  165|  39.0k|   }
_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|  39.0k|      {
   73|  39.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|  39.0k|         else {
   84|  39.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.0k|      }
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|  39.0k|      {
   44|  39.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.0k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  39.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.0k|      else {
  108|  39.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.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|  39.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|  39.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|  39.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|  39.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|  39.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|  39.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.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|  39.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.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|  39.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.4k, False: 4.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|  34.4k|            else if constexpr( has_apply0_bool ) {
  153|  34.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.4k|            }
  155|  34.4k|         }
  156|  39.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.4k, False: 4.57k]
  ------------------
  157|  34.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.4k|         }
  159|  4.57k|         else {
  160|  4.57k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.57k|         }
  162|  39.0k|         (void)m( result );
  163|  39.0k|         return result;
  164|  39.0k|      }
  165|  39.0k|   }
_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|  39.0k|      {
   73|  39.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|  39.0k|         else {
   84|  39.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.0k|      }
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|  39.0k|      {
   59|  39.0k|         return Rule::match( in );
   60|  39.0k|      }

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

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   165k|         else {
   92|   165k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   165k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   165k|         }
   94|   165k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   219k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   292k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   292k|         else {
   92|   292k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   292k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   292k|         }
   94|   292k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  6.21M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  3.71M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.49M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   219k|      {}
_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|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_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|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  82.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|  82.5k|         else {
   92|  82.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  82.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  82.5k|         }
   94|  82.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  82.5k|      {}
_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|  82.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|  82.5k|         else {
   92|  82.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  82.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  82.5k|         }
   94|  82.5k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  82.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  82.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|  82.5k|         else {
   92|  82.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  82.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  82.5k|         }
   94|  82.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  82.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  68.8k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.7k|         else {
   92|  13.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.7k|         }
   94|  13.7k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSF_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.7k|         else {
   92|  13.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.7k|         }
   94|  13.7k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  13.7k|      {}
_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|   865k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   865k|         else {
   92|   865k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   865k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   865k|         }
   94|   865k|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   865k|      {}
_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|   865k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   865k|         else {
   92|   865k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   865k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   865k|         }
   94|   865k|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   865k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|   865k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   865k|         else {
   92|   865k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   865k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   865k|         }
   94|   865k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   904k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  48.2k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   856k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   851k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_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_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   851k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   851k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   851k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.7k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.7k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  13.7k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  68.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0ITtTpTyENS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  13.7k|      {
   75|  13.7k|         return Action< Rule >::apply0( st... );
   76|  13.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  13.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  68.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.6k|         else {
   92|  43.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.6k|         }
   94|  43.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  39.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.88k|      {}
_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.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|  3.88k|         else {
   92|  3.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.88k|         }
   94|  3.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.88k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.84k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.03k|      {}
_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.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.03k|         else {
   92|  1.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.03k|         }
   94|  1.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.03k|      {}
_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.02k|      {}
_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.02k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.02k|         else {
   92|  1.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.02k|         }
   94|  1.02k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.02k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    881|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    144|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    144|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    144|         else {
   92|    144|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    144|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    144|         }
   94|    144|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    144|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     38|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5applyITtTpTyENS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  43.5k|      {
   65|  43.5k|         const typename ParseInput::action_t action_input( begin, in );
   66|  43.5k|         return Action< Rule >::apply( action_input, st... );
   67|  43.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  43.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  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_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  43.5k|      {}
_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|  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_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   120k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   120k|         else {
   92|   120k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   120k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   120k|         }
   94|   120k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.27M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   120k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   120k|         else {
   92|   120k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   120k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   120k|         }
   94|   120k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.22M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  48.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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   850k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.3k|         else {
   92|  46.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.3k|         }
   94|  46.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.65M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  55.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|  55.8k|         else {
   92|  55.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  55.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  55.8k|         }
   94|  55.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.31M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.80M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.65M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.1k|         else {
   92|  43.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.1k|         }
   94|  43.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.80M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.76M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  42.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  42.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.81k|         else {
   92|  2.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.81k|         }
   94|  2.81k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    128|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   807k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     32|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5applyITtTpTyENS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.78k|      {
   65|  2.78k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.78k|         return Action< Rule >::apply( action_input, st... );
   67|  2.78k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.77k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  43.5k|      {}
_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|  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_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  43.5k|      {}
_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|  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_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|  41.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  41.9k|         else {
   92|  41.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.9k|         }
   94|  41.9k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  41.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|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.0k|      {}
_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|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.0k|      {}
_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.83k|      {
   65|  3.83k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.83k|         return Action< Rule >::apply( action_input, st... );
   67|  3.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.1k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   809k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   809k|         else {
   92|   809k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   809k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   809k|         }
   94|   809k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   809k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   809k|         else {
   92|   809k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   809k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   809k|         }
   94|   809k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   822k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   822k|         else {
   92|   822k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   822k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   822k|         }
   94|   822k|      }
_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.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|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.81k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.81k|      {}
_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.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|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  41.5k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.5k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.15k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.3k|      {}
_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.58k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.58k|         else {
   92|  3.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.58k|         }
   94|  3.58k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.74k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.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|  3.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|  3.37k|         else {
   92|  3.37k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.37k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.37k|         }
   94|  3.37k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.68k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.17k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.17k|         else {
   92|  3.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.17k|         }
   94|  3.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.82k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.28k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  26.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.27k|         else {
   92|  2.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.27k|         }
   94|  2.27k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.01k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.7k|      {}
_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.73k|      {
   65|  1.73k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.73k|         return Action< Rule >::apply( action_input, st... );
   67|  1.73k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  17.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  23.7k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  41.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  41.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  28.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.61k|         else {
   92|  4.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.61k|         }
   94|  4.61k|      }
_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.33k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.33k|         else {
   92|  2.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.33k|         }
   94|  2.33k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.33k|      {}
_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.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.27k|         else {
   92|  2.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.27k|         }
   94|  2.27k|      }
_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|   803k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   803k|         else {
   92|   803k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   803k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   803k|         }
   94|   803k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.27k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     59|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.27k|         else {
   92|  2.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.27k|         }
   94|  2.27k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  26.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  24.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.88k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.71k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   806k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   806k|         else {
   92|   806k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   806k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   806k|         }
   94|   806k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   806k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   806k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   806k|         else {
   92|   806k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   806k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   806k|         }
   94|   806k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.61M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.61M|         else {
   92|  1.61M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.61M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.61M|         }
   94|  1.61M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.61M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.61M|         else {
   92|  1.61M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.61M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.61M|         }
   94|  1.61M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.60M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.60M|         else {
   92|  1.60M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.60M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.60M|         }
   94|  1.60M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   804k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   804k|         else {
   92|   804k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   804k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   804k|         }
   94|   804k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   804k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   804k|         else {
   92|   804k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   804k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   804k|         }
   94|   804k|      }
_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|   804k|      {
   65|   804k|         const typename ParseInput::action_t action_input( begin, in );
   66|   804k|         return Action< Rule >::apply( action_input, st... );
   67|   804k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   804k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.61k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.34k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    465|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.6k|         else {
   92|  44.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.6k|         }
   94|  44.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.6k|      {}
_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|  44.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|  44.6k|         else {
   92|  44.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.6k|         }
   94|  44.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.6k|         else {
   92|  44.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.6k|         }
   94|  44.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.26k|      {
   65|  4.26k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.26k|         return Action< Rule >::apply( action_input, st... );
   67|  4.26k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.25k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.4k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   463k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   463k|         else {
   92|   463k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   463k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   463k|         }
   94|   463k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   463k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   463k|         else {
   92|   463k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   463k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   463k|         }
   94|   463k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   473k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   473k|         else {
   92|   473k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   473k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   473k|         }
   94|   473k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  26.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.6k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_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.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|      }
_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.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.05k|         else {
   92|  3.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.05k|         }
   94|  3.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.86k|         else {
   92|  2.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.86k|         }
   94|  2.86k|      }
_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.50k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50k|         else {
   92|  2.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50k|         }
   94|  2.50k|      }
_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.92k|      {
   65|  1.92k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.92k|         return Action< Rule >::apply( action_input, st... );
   67|  1.92k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.24k|         else {
   92|  4.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.24k|         }
   94|  4.24k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.14k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.14k|         else {
   92|  6.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.14k|         }
   94|  6.14k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.10k|         else {
   92|  3.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.10k|         }
   94|  3.10k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  18.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|  3.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|  3.05k|         else {
   92|  3.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.05k|         }
   94|  3.05k|      }
_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|   457k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   457k|         else {
   92|   457k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   457k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   457k|         }
   94|   457k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  17.6k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    296|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.64k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   459k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   459k|         else {
   92|   459k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   459k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   459k|         }
   94|   459k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   502k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   459k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   459k|         else {
   92|   459k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   459k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   459k|         }
   94|   459k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  58.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   997k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  57.8M|      {}
_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|   458k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   458k|         else {
   92|   458k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   458k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   458k|         }
   94|   458k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   458k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   458k|         else {
   92|   458k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   458k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   458k|         }
   94|   458k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   495k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  16.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.7M|         else {
   92|  16.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.7M|         }
   94|  16.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.3M|         else {
   92|  16.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.3M|         }
   94|  16.3M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  57.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.3M|         else {
   92|  16.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.3M|         }
   94|  16.3M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  57.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.3M|         else {
   92|  16.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.3M|         }
   94|  16.3M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   106M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   948k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   105M|      {}
_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|   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_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|   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_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   800k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   948k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   948k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   321k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   627k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_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_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   321k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   201k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   201k|         else {
   92|   201k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   201k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   201k|         }
   94|   201k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   321k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    265|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    265|      {
   49|    265|#if defined( __cpp_exceptions )
   50|    265|         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|    265|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   321k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   627k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   627k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   193k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   193k|         else {
   92|   193k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   193k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   193k|         }
   94|   193k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   938k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   339k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   599k|      {}
_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|  44.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|  44.9k|         else {
   92|  44.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.9k|         }
   94|  44.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|  44.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|  44.9k|         else {
   92|  44.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.9k|         }
   94|  44.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   268k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   268k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   268k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   358k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  98.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|  98.4k|         else {
   92|  98.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  98.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  98.4k|         }
   94|  98.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   358k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   349k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.60k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.57k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.57k|         else {
   92|  4.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.57k|         }
   94|  4.57k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   799k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    352|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    352|      {
   49|    352|#if defined( __cpp_exceptions )
   50|    352|         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|    352|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   799k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  57.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.0M|         else {
   92|  16.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.0M|         }
   94|  16.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   105M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   105M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.63k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  57.8M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.36k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   493k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.36k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.36k|      {
   49|  1.36k|#if defined( __cpp_exceptions )
   50|  1.36k|         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.36k|      }
_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|   458k|      {
   65|   458k|         const typename ParseInput::action_t action_input( begin, in );
   66|   458k|         return Action< Rule >::apply( action_input, st... );
   67|   458k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   493k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.89k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  22.1k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.23k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.52k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.52k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.7k|         else {
   92|  40.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.7k|         }
   94|  40.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.7k|      {}
_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|  40.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|  40.7k|         else {
   92|  40.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.7k|         }
   94|  40.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.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|  40.7k|         else {
   92|  40.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.7k|         }
   94|  40.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.7k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.49k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  13.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  13.2k|         else {
   92|  13.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2k|         }
   94|  13.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  13.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  13.2k|         else {
   92|  13.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2k|         }
   94|  13.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  22.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|  22.7k|         else {
   92|  22.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.7k|         }
   94|  22.7k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_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.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_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.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_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.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_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.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.12k|         else {
   92|  4.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.12k|         }
   94|  4.12k|      }
_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.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.47k|         else {
   92|  3.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.47k|         }
   94|  3.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.12k|         else {
   92|  3.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.12k|         }
   94|  3.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.93k|         else {
   92|  2.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.93k|         }
   94|  2.93k|      }
_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.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.67k|         else {
   92|  2.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.67k|         }
   94|  2.67k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.22k|      {
   65|  2.22k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.22k|         return Action< Rule >::apply( action_input, st... );
   67|  2.22k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.47k|         else {
   92|  4.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.47k|         }
   94|  4.47k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.31k|      {
   88|       |         if constexpr( internal::has_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.31k|         else {
   92|  6.31k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.31k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.31k|         }
   94|  6.31k|      }
_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|  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|      }
_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|  3.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.13k|         else {
   92|  3.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.13k|         }
   94|  3.13k|      }
_ZN3tao5pegtl6normalINS0_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.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|  6.55k|         else {
   92|  6.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.55k|         }
   94|  6.55k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.11k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.11k|         else {
   92|  3.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.11k|         }
   94|  3.11k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.92k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.92k|         else {
   92|  8.92k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.92k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.92k|         }
   94|  8.92k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.92k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.92k|         else {
   92|  8.92k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.92k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.92k|         }
   94|  8.92k|      }
_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.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.69k|         else {
   92|  7.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.69k|         }
   94|  7.69k|      }
_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.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.69k|         else {
   92|  7.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.69k|         }
   94|  7.69k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.91M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.91M|         else {
   92|  6.91M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.91M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.91M|         }
   94|  6.91M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.90M|         else {
   92|  6.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.90M|         }
   94|  6.90M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.90M|         else {
   92|  6.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.90M|         }
   94|  6.90M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.90M|         else {
   92|  6.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.90M|         }
   94|  6.90M|      }
_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|  76.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|  76.3k|         else {
   92|  76.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  76.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  76.3k|         }
   94|  76.3k|      }
_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|  76.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|  76.3k|         else {
   92|  76.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  76.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  76.3k|         }
   94|  76.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  76.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|  76.3k|         else {
   92|  76.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  76.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  76.3k|         }
   94|  76.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  76.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|  76.3k|         else {
   92|  76.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  76.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  76.3k|         }
   94|  76.3k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  20.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|  20.4k|         else {
   92|  20.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.4k|         }
   94|  20.4k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  20.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|  20.4k|         else {
   92|  20.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.4k|         }
   94|  20.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  40.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  40.8k|         else {
   92|  40.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.8k|         }
   94|  40.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  55.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|  55.9k|         else {
   92|  55.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  55.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  55.9k|         }
   94|  55.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  92.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|  92.2k|         else {
   92|  92.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.2k|         }
   94|  92.2k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  32.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  32.4k|         else {
   92|  32.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.4k|         }
   94|  32.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  32.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  32.4k|         else {
   92|  32.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.4k|         }
   94|  32.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  23.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|  23.4k|         else {
   92|  23.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  23.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  23.4k|         }
   94|  23.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    359|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    359|         else {
   92|    359|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    359|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    359|         }
   94|    359|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.83M|         else {
   92|  6.83M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.83M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.83M|         }
   94|  6.83M|      }
_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.38k|      {
   65|  7.38k|         const typename ParseInput::action_t action_input( begin, in );
   66|  7.38k|         return Action< Rule >::apply( action_input, st... );
   67|  7.38k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.6k|      {}
_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|  36.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|  36.6k|         else {
   92|  36.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.6k|         }
   94|  36.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  36.6k|      {}
_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|  36.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|  36.6k|         else {
   92|  36.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.6k|         }
   94|  36.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  36.6k|      {}
_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|  36.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|  36.6k|         else {
   92|  36.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.6k|         }
   94|  36.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  36.6k|      {}
_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.17k|      {
   65|  3.17k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.17k|         return Action< Rule >::apply( action_input, st... );
   67|  3.17k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.17k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.4k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.26k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.26k|         else {
   92|  9.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.26k|         }
   94|  9.26k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.26k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.26k|         else {
   92|  9.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.26k|         }
   94|  9.26k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.6k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  15.6k|         else {
   92|  15.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6k|         }
   94|  15.6k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.93k|         else {
   92|  2.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.93k|         }
   94|  2.93k|      }
_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.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|      }
_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.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|      }
_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.34k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.34k|         else {
   92|  2.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.34k|         }
   94|  2.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.07k|         else {
   92|  2.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.07k|         }
   94|  2.07k|      }
_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.16k|      {
   65|  1.16k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.16k|         return Action< Rule >::apply( action_input, st... );
   67|  1.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.15k|         else {
   92|  3.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.15k|         }
   94|  3.15k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.15k|         else {
   92|  4.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.15k|         }
   94|  4.15k|      }
_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.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.10k|         else {
   92|  2.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.10k|         }
   94|  2.10k|      }
_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.05k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.05k|         else {
   92|  2.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.05k|         }
   94|  2.05k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.93k|         else {
   92|  4.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.93k|         }
   94|  4.93k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.04k|         else {
   92|  2.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.04k|         }
   94|  2.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.70k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.70k|         else {
   92|  6.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.70k|         }
   94|  6.70k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.70k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.70k|         else {
   92|  6.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.70k|         }
   94|  6.70k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.03M|      {
   88|       |         if constexpr( internal::has_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.03M|         else {
   92|  6.03M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.03M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.03M|         }
   94|  6.03M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.02M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.02M|         else {
   92|  6.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.02M|         }
   94|  6.02M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.02M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.02M|         else {
   92|  6.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.02M|         }
   94|  6.02M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.02M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.02M|         else {
   92|  6.02M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.02M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.02M|         }
   94|  6.02M|      }
_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|  85.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|  85.9k|         else {
   92|  85.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.9k|         }
   94|  85.9k|      }
_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|  85.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|  85.9k|         else {
   92|  85.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.9k|         }
   94|  85.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  85.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|  85.9k|         else {
   92|  85.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.9k|         }
   94|  85.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  85.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|  85.9k|         else {
   92|  85.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  85.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  85.9k|         }
   94|  85.9k|      }
_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|  37.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.8k|         else {
   92|  37.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.8k|         }
   94|  37.8k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  37.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.8k|         else {
   92|  37.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.8k|         }
   94|  37.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  75.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|  75.6k|         else {
   92|  75.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.6k|         }
   94|  75.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.1k|         else {
   92|  48.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.1k|         }
   94|  48.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  68.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|  68.6k|         else {
   92|  68.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  68.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  68.6k|         }
   94|  68.6k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.7k|         else {
   92|  14.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.7k|         }
   94|  14.7k|      }
_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|  14.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|  14.7k|         else {
   92|  14.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.7k|         }
   94|  14.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  33.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|  33.3k|         else {
   92|  33.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.3k|         }
   94|  33.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_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_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.93M|      {
   88|       |         if constexpr( internal::has_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.93M|         else {
   92|  5.93M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.93M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.93M|         }
   94|  5.93M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.60k|      {
   65|  5.60k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.60k|         return Action< Rule >::apply( action_input, st... );
   67|  5.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.54k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.54k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  33.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.8k|         else {
   92|  33.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.8k|         }
   94|  33.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  33.8k|      {}
_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|  33.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.8k|         else {
   92|  33.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.8k|         }
   94|  33.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  33.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  33.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.8k|         else {
   92|  33.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.8k|         }
   94|  33.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  33.8k|      {}
_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.57k|      {
   65|  3.57k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.57k|         return Action< Rule >::apply( action_input, st... );
   67|  3.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.57k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.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|  9.34k|         else {
   92|  9.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.34k|         }
   94|  9.34k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.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|  9.34k|         else {
   92|  9.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.34k|         }
   94|  9.34k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.6k|         else {
   92|  16.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.6k|         }
   94|  16.6k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.31k|      {
   88|       |         if constexpr( internal::has_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.31k|         else {
   92|  3.31k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.31k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.31k|         }
   94|  3.31k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.11k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.11k|         else {
   92|  3.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.11k|         }
   94|  3.11k|      }
_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.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.91k|         else {
   92|  2.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.91k|         }
   94|  2.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.57k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.57k|         else {
   92|  2.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.57k|         }
   94|  2.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.19k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.19k|         else {
   92|  2.19k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.19k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.19k|         }
   94|  2.19k|      }
_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.55k|      {
   65|  1.55k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.55k|         return Action< Rule >::apply( action_input, st... );
   67|  1.55k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.55k|         else {
   92|  3.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.55k|         }
   94|  3.55k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.12k|         else {
   92|  4.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.12k|         }
   94|  4.12k|      }
_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|  2.08k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.08k|         else {
   92|  2.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.08k|         }
   94|  2.08k|      }
_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|  2.05k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.05k|         else {
   92|  2.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.05k|         }
   94|  2.05k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.21k|         else {
   92|  4.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.21k|         }
   94|  4.21k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.04k|         else {
   92|  2.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.04k|         }
   94|  2.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.16k|         else {
   92|  6.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.16k|         }
   94|  6.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.16k|         else {
   92|  6.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.16k|         }
   94|  6.16k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.58k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.58k|         else {
   92|  5.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.58k|         }
   94|  5.58k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.58k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.58k|         else {
   92|  5.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.58k|         }
   94|  5.58k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.38M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.38M|         else {
   92|  2.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.38M|         }
   94|  2.38M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.38M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.38M|         else {
   92|  2.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.38M|         }
   94|  2.38M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.38M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.38M|         else {
   92|  2.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.38M|         }
   94|  2.38M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.38M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.38M|         else {
   92|  2.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.38M|         }
   94|  2.38M|      }
_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.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.35k|         else {
   92|  5.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.35k|         }
   94|  5.35k|      }
_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.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.35k|         else {
   92|  5.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.35k|         }
   94|  5.35k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.35k|         else {
   92|  5.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.35k|         }
   94|  5.35k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.35k|         else {
   92|  5.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.35k|         }
   94|  5.35k|      }
_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.46k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.46k|         else {
   92|  1.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.46k|         }
   94|  1.46k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  1.46k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.46k|         else {
   92|  1.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.46k|         }
   94|  1.46k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.91k|         else {
   92|  2.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.91k|         }
   94|  2.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.89k|         else {
   92|  3.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.89k|         }
   94|  3.89k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.24k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.24k|         else {
   92|  5.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.24k|         }
   94|  5.24k|      }
_ZN3tao5pegtl6normalINS0_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.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.00k|         else {
   92|  1.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.00k|         }
   94|  1.00k|      }
_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.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.00k|         else {
   92|  1.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.00k|         }
   94|  1.00k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.88k|         else {
   92|  2.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88k|         }
   94|  2.88k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    245|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    245|         else {
   92|    245|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    245|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    245|         }
   94|    245|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.37M|      {
   88|       |         if constexpr( internal::has_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.37M|         else {
   92|  2.37M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.37M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.37M|         }
   94|  2.37M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.37k|      {
   65|  5.37k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.37k|         return Action< Rule >::apply( action_input, st... );
   67|  5.37k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.4k|         else {
   92|  30.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.4k|         }
   94|  30.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.4k|         else {
   92|  30.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.4k|         }
   94|  30.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  30.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  30.4k|         else {
   92|  30.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.4k|         }
   94|  30.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5applyITtTpTyENS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.12k|      {
   65|  4.12k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.12k|         return Action< Rule >::apply( action_input, st... );
   67|  4.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.12k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  26.3k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.2k|         else {
   92|  11.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.2k|         }
   94|  11.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.2k|         else {
   92|  11.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.2k|         }
   94|  11.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  21.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  21.5k|         else {
   92|  21.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.5k|         }
   94|  21.5k|      }
_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|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.88k|         else {
   92|  3.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.88k|         }
   94|  3.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.66k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.66k|         else {
   92|  3.66k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.66k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.66k|         }
   94|  3.66k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.47k|         else {
   92|  3.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.47k|         }
   94|  3.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.10k|         else {
   92|  3.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.10k|         }
   94|  3.10k|      }
_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.68k|      {
   88|       |         if constexpr( internal::has_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.68k|         else {
   92|  2.68k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.68k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.68k|         }
   94|  2.68k|      }
_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.62k|      {
   65|  1.62k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.62k|         return Action< Rule >::apply( action_input, st... );
   67|  1.62k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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|      }
_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.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|  2.85k|         else {
   92|  2.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.85k|         }
   94|  2.85k|      }
_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.79k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.79k|         else {
   92|  2.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.79k|         }
   94|  2.79k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.49k|         else {
   92|  5.49k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.49k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.49k|         }
   94|  5.49k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.78k|         else {
   92|  2.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.78k|         }
   94|  2.78k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.03k|         else {
   92|  8.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.03k|         }
   94|  8.03k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.03k|         else {
   92|  8.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.03k|         }
   94|  8.03k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.61k|         else {
   92|  6.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.61k|         }
   94|  6.61k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.61k|         else {
   92|  6.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.61k|         }
   94|  6.61k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.11M|      {
   88|       |         if constexpr( internal::has_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.11M|         else {
   92|  8.11M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.11M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.11M|         }
   94|  8.11M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.10M|      {
   88|       |         if constexpr( internal::has_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.10M|         else {
   92|  8.10M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.10M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.10M|         }
   94|  8.10M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.10M|      {
   88|       |         if constexpr( internal::has_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.10M|         else {
   92|  8.10M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.10M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.10M|         }
   94|  8.10M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.10M|      {
   88|       |         if constexpr( internal::has_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.10M|         else {
   92|  8.10M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.10M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.10M|         }
   94|  8.10M|      }
_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|   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_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|   106k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   106k|         else {
   92|   106k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   106k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   106k|         }
   94|   106k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   106k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   106k|         else {
   92|   106k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   106k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   106k|         }
   94|   106k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.0k|         else {
   92|  44.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.0k|         }
   94|  44.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.0k|         else {
   92|  44.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.0k|         }
   94|  44.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  62.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|  62.6k|         else {
   92|  62.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  62.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  62.6k|         }
   94|  62.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   102k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   102k|         else {
   92|   102k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   102k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   102k|         }
   94|   102k|      }
_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|  30.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|  30.8k|         else {
   92|  30.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.8k|         }
   94|  30.8k|      }
_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|  30.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|  30.8k|         else {
   92|  30.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.8k|         }
   94|  30.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.7k|         else {
   92|  31.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.7k|         }
   94|  31.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    524|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    524|         else {
   92|    524|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    524|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    524|         }
   94|    524|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.00M|      {
   88|       |         if constexpr( internal::has_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.00M|         else {
   92|  8.00M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.00M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.00M|         }
   94|  8.00M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  6.32k|      {
   65|  6.32k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.32k|         return Action< Rule >::apply( action_input, st... );
   67|  6.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  26.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  26.7k|      {}
_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|  26.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|  26.7k|         else {
   92|  26.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.7k|         }
   94|  26.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.7k|      {}
_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|  26.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|  26.7k|         else {
   92|  26.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.7k|         }
   94|  26.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.7k|      {}
_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|  26.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|  26.7k|         else {
   92|  26.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.7k|         }
   94|  26.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  26.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5applyITtTpTyENS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.84k|      {
   65|  4.84k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.84k|         return Action< Rule >::apply( action_input, st... );
   67|  4.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.84k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  21.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   167k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   167k|         else {
   92|   167k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   167k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   167k|         }
   94|   167k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   167k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   167k|         else {
   92|   167k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   167k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   167k|         }
   94|   167k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.53M|      {
   88|       |         if constexpr( internal::has_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.53M|         else {
   92|  1.53M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.53M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.53M|         }
   94|  1.53M|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  4.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  4.83k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_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.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|  3.76k|         else {
   92|  3.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.76k|         }
   94|  3.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.41k|         else {
   92|  3.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.41k|         }
   94|  3.41k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.10k|         else {
   92|  3.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.10k|         }
   94|  3.10k|      }
_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.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.86k|         else {
   92|  2.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.86k|         }
   94|  2.86k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.47k|         else {
   92|  2.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.47k|         }
   94|  2.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.42k|      {
   65|  3.42k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.42k|         return Action< Rule >::apply( action_input, st... );
   67|  3.42k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.83k|         else {
   92|  4.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.83k|         }
   94|  4.83k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.87k|         else {
   92|  7.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.87k|         }
   94|  7.87k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.96k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.96k|         else {
   92|  3.96k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.96k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.96k|         }
   94|  3.96k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.96k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.90k|         else {
   92|  3.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.90k|         }
   94|  3.90k|      }
_ZN3tao5pegtl6normalINS0_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|   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|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.90k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     52|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.90k|         else {
   92|  3.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.90k|         }
   94|  3.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.72k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.11k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   161k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   480k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   809k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   809k|         else {
   92|   809k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   809k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   809k|         }
   94|   809k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   328k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   152k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   319k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   319k|         else {
   92|   319k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   319k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   319k|         }
   94|   319k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   319k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   319k|         else {
   92|   319k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   319k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   319k|         }
   94|   319k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   319k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   319k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   319k|         else {
   92|   319k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   319k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   319k|         }
   94|   319k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   150k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   150k|         else {
   92|   150k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   150k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   150k|         }
   94|   150k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   319k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     58|      {}
_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|   159k|      {
   65|   159k|         const typename ParseInput::action_t action_input( begin, in );
   66|   159k|         return Action< Rule >::apply( action_input, st... );
   67|   159k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   159k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.19k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  4.38k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    441|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.3k|      {}
_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|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_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|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_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|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5applyITtTpTyENS3_25with_connect_type_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.08k|      {
   65|  3.08k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.08k|         return Action< Rule >::apply( action_input, st... );
   67|  3.08k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.08k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.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|  9.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.16k|         else {
   92|  9.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.16k|         }
   94|  9.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.16k|         else {
   92|  9.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.16k|         }
   94|  9.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  18.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|  18.8k|         else {
   92|  18.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.8k|         }
   94|  18.8k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_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.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.86k|         else {
   92|  2.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.86k|         }
   94|  2.86k|      }
_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.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|      }
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.21k|         else {
   92|  2.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.21k|         }
   94|  2.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_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.95k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.95k|         else {
   92|  1.95k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.95k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.95k|         }
   94|  1.95k|      }
_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.31k|      {
   65|  1.31k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.31k|         return Action< Rule >::apply( action_input, st... );
   67|  1.31k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalINS0_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.97k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.97k|         else {
   92|  4.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.97k|         }
   94|  4.97k|      }
_ZN3tao5pegtl6normalINS0_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.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_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.46k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.46k|         else {
   92|  2.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.46k|         }
   94|  2.46k|      }
_ZN3tao5pegtl6normalINS0_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.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_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_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|  6.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|  6.12k|         else {
   92|  6.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.12k|         }
   94|  6.12k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.12k|         else {
   92|  6.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.12k|         }
   94|  6.12k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.22k|         else {
   92|  5.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.22k|         }
   94|  5.22k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.22k|         else {
   92|  5.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.22k|         }
   94|  5.22k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.25M|      {
   88|       |         if constexpr( internal::has_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.25M|         else {
   92|  8.25M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.25M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.25M|         }
   94|  8.25M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.25M|      {
   88|       |         if constexpr( internal::has_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.25M|         else {
   92|  8.25M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.25M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.25M|         }
   94|  8.25M|      }
_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|  8.25M|      {
   88|       |         if constexpr( internal::has_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.25M|         else {
   92|  8.25M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.25M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.25M|         }
   94|  8.25M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.25M|      {
   88|       |         if constexpr( internal::has_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.25M|         else {
   92|  8.25M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.25M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.25M|         }
   94|  8.25M|      }
_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|   101k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   101k|         else {
   92|   101k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   101k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   101k|         }
   94|   101k|      }
_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|   101k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   101k|         else {
   92|   101k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   101k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   101k|         }
   94|   101k|      }
_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|   101k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   101k|         else {
   92|   101k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   101k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   101k|         }
   94|   101k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   101k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   101k|         else {
   92|   101k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   101k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   101k|         }
   94|   101k|      }
_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|  24.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|  24.5k|         else {
   92|  24.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.5k|         }
   94|  24.5k|      }
_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|  24.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|  24.5k|         else {
   92|  24.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.5k|         }
   94|  24.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  49.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|  49.0k|         else {
   92|  49.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  49.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  49.0k|         }
   94|  49.0k|      }
_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|  77.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|  77.2k|         else {
   92|  77.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  77.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  77.2k|         }
   94|  77.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   115k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   115k|         else {
   92|   115k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   115k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   115k|         }
   94|   115k|      }
_ZN3tao5pegtl6normalINS0_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|  34.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|  34.1k|         else {
   92|  34.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.1k|         }
   94|  34.1k|      }
_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|  34.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|  34.1k|         else {
   92|  34.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.1k|         }
   94|  34.1k|      }
_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|  43.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|  43.0k|         else {
   92|  43.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.0k|         }
   94|  43.0k|      }
_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.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.22k|         else {
   92|  1.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.22k|         }
   94|  1.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.14M|         else {
   92|  8.14M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.14M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.14M|         }
   94|  8.14M|      }
_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.97k|      {
   65|  4.97k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.97k|         return Action< Rule >::apply( action_input, st... );
   67|  4.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.47k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.47k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.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|  19.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|  19.5k|         else {
   92|  19.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.5k|         }
   94|  19.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.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|  19.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|  19.5k|         else {
   92|  19.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.5k|         }
   94|  19.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|  19.5k|         else {
   92|  19.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.5k|         }
   94|  19.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.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.25k|      {
   65|  6.25k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.25k|         return Action< Rule >::apply( action_input, st... );
   67|  6.25k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.24k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   652k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   652k|         else {
   92|   652k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   652k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   652k|         }
   94|   652k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   652k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   652k|         else {
   92|   652k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   652k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   652k|         }
   94|   652k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   698k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   698k|         else {
   92|   698k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   698k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   698k|         }
   94|   698k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  6.21k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  6.21k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.17k|         else {
   92|  6.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.17k|         }
   94|  6.17k|      }
_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.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.91k|         else {
   92|  5.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.91k|         }
   94|  5.91k|      }
_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.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.69k|         else {
   92|  5.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.69k|         }
   94|  5.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.18k|         else {
   92|  5.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.18k|         }
   94|  5.18k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.06k|         else {
   92|  5.06k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.06k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.06k|         }
   94|  5.06k|      }
_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.34k|      {
   65|  1.34k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.34k|         return Action< Rule >::apply( action_input, st... );
   67|  1.34k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_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.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_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.78k|      {}
_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.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_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   644k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   644k|         else {
   92|   644k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   644k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   644k|         }
   94|   644k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.55k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     36|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.91k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.10k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   649k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   649k|         else {
   92|   649k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   649k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   649k|         }
   94|   649k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   649k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   649k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   649k|         else {
   92|   649k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   649k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   649k|         }
   94|   649k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   649k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   649k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   649k|         else {
   92|   649k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   649k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   649k|         }
   94|   649k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   649k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    310|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   648k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   649k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   649k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   649k|         else {
   92|   649k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   649k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   649k|         }
   94|   649k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   649k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   649k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   649k|         else {
   92|   649k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   649k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   649k|         }
   94|   649k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   649k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   647k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.10k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   647k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   647k|         else {
   92|   647k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   647k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   647k|         }
   94|   647k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   647k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  27.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|  27.0M|         else {
   92|  27.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.0M|         }
   94|  27.0M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  27.0M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  26.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   647k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   647k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   647k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.10k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   647k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   647k|         else {
   92|   647k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   647k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   647k|         }
   94|   647k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   647k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   647k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   647k|         else {
   92|   647k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   647k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   647k|         }
   94|   647k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   647k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   647k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   647k|         else {
   92|   647k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   647k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   647k|         }
   94|   647k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   647k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  44.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   603k|      {}
_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|  44.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|  44.7k|         else {
   92|  44.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7k|         }
   94|  44.7k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.7k|         else {
   92|  44.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7k|         }
   94|  44.7k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  44.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  48.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|  48.3M|         else {
   92|  48.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.3M|         }
   94|  48.3M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  48.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  44.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  48.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.2M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.2M|         else {
   92|  48.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.2M|         }
   94|  48.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.2M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.2M|         else {
   92|  48.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.2M|         }
   94|  48.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  48.2M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  48.2M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.2M|         else {
   92|  48.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.2M|         }
   94|  48.2M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   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_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|   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_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   148k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_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_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   148k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   148k|         else {
   92|   148k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   148k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   148k|         }
   94|   148k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.3k|         else {
   92|  38.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.3k|         }
   94|  38.3k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.3k|         else {
   92|  38.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.3k|         }
   94|  38.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  76.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|  76.7k|         else {
   92|  76.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  76.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  76.7k|         }
   94|  76.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   145k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   145k|         else {
   92|   145k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   145k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   145k|         }
   94|   145k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  29.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.1k|         else {
   92|  29.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.1k|         }
   94|  29.1k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  29.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.1k|         else {
   92|  29.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.1k|         }
   94|  29.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  81.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|  81.2k|         else {
   92|  81.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  81.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  81.2k|         }
   94|  81.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    342|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    342|         else {
   92|    342|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    342|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    342|         }
   94|    342|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   148k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     68|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     68|      {
   49|     68|#if defined( __cpp_exceptions )
   50|     68|         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|     68|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   148k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  48.1M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  48.1M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.1M|         else {
   92|  48.1M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.1M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.1M|         }
   94|  48.1M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  48.2M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    278|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  44.3k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    278|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    278|      {
   49|    278|#if defined( __cpp_exceptions )
   50|    278|         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|    278|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  44.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   603k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   647k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   647k|      {
   65|   647k|         const typename ParseInput::action_t action_input( begin, in );
   66|   647k|         return Action< Rule >::apply( action_input, st... );
   67|   647k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   645k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.10k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.14k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    744|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.14k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  14.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.14k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  14.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.0k|         else {
   92|  14.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.0k|         }
   94|  14.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  14.0k|      {}
_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|  14.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|  14.0k|         else {
   92|  14.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.0k|         }
   94|  14.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  14.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.0k|         else {
   92|  14.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.0k|         }
   94|  14.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  14.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.05k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.0k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.83k|         else {
   92|  9.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.83k|         }
   94|  9.83k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.83k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.83k|         else {
   92|  9.83k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.83k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.83k|         }
   94|  9.83k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.1k|         else {
   92|  16.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.1k|         }
   94|  16.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.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.82k|         else {
   92|  3.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.82k|         }
   94|  3.82k|      }
_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.57k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_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.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_13label_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_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.88k|         else {
   92|  2.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88k|         }
   94|  2.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.39k|      {
   65|  1.39k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.39k|         return Action< Rule >::apply( action_input, st... );
   67|  1.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.03k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.48k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.48k|         else {
   92|  4.48k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.48k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.48k|         }
   94|  4.48k|      }
_ZN3tao5pegtl6normalINS0_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.28k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.28k|         else {
   92|  2.28k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.28k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.28k|         }
   94|  2.28k|      }
_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.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.21k|         else {
   92|  2.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.21k|         }
   94|  2.21k|      }
_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.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|  4.39k|         else {
   92|  4.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.39k|         }
   94|  4.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.19k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.19k|         else {
   92|  2.19k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.19k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.19k|         }
   94|  2.19k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.87k|         else {
   92|  6.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.87k|         }
   94|  6.87k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.87k|         else {
   92|  6.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.87k|         }
   94|  6.87k|      }
_ZN3tao5pegtl6normalINS0_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.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.00k|         else {
   92|  6.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.00k|         }
   94|  6.00k|      }
_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.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.00k|         else {
   92|  6.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.00k|         }
   94|  6.00k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.90M|         else {
   92|  9.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.90M|         }
   94|  9.90M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.90M|         else {
   92|  9.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.90M|         }
   94|  9.90M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.90M|         else {
   92|  9.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.90M|         }
   94|  9.90M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.90M|         else {
   92|  9.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.90M|         }
   94|  9.90M|      }
_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|   179k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   179k|         else {
   92|   179k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   179k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   179k|         }
   94|   179k|      }
_ZN3tao5pegtl6normalINS0_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|   179k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   179k|         else {
   92|   179k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   179k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   179k|         }
   94|   179k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   179k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   179k|         else {
   92|   179k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   179k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   179k|         }
   94|   179k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   179k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   179k|         else {
   92|   179k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   179k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   179k|         }
   94|   179k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  54.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|  54.0k|         else {
   92|  54.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  54.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  54.0k|         }
   94|  54.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  54.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|  54.0k|         else {
   92|  54.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  54.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  54.0k|         }
   94|  54.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   108k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   108k|         else {
   92|   108k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   108k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   108k|         }
   94|   108k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   125k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   125k|         else {
   92|   125k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   125k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   125k|         }
   94|   125k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   215k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   215k|         else {
   92|   215k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   215k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   215k|         }
   94|   215k|      }
_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|  81.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|  81.1k|         else {
   92|  81.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  81.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  81.1k|         }
   94|  81.1k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  81.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|  81.1k|         else {
   92|  81.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  81.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  81.1k|         }
   94|  81.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.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|  44.6k|         else {
   92|  44.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.6k|         }
   94|  44.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.63k|         else {
   92|  1.63k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.63k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.63k|         }
   94|  1.63k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.72M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.72M|         else {
   92|  9.72M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.72M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.72M|         }
   94|  9.72M|      }
_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.69k|      {
   65|  5.69k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.69k|         return Action< Rule >::apply( action_input, st... );
   67|  5.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.33k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.33k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  32.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_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|  29.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.8k|         else {
   92|  29.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.8k|         }
   94|  29.8k|      }
_ZN3tao5pegtl6normalINS0_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|  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_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  29.5k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  7.77k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  38.8k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.8k|         else {
   92|  38.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.8k|         }
   94|  38.8k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  38.8k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  38.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  38.9k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  39.0k|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  39.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|  39.0k|         else {
   92|  39.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.0k|         }
   94|  39.0k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  39.0k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  39.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|  39.0k|         else {
   92|  39.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.0k|         }
   94|  39.0k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|  4.57k|      {
   49|  4.57k|#if defined( __cpp_exceptions )
   50|  4.57k|         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.57k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  34.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  34.4k|      {}

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

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

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

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