_ZN7DNSName19throwSafeRangeErrorERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS0_17basic_string_viewIcS3_EE:
   64|    509|{
   65|    509|  std::string dots;
   66|    509|  auto length = content.size();
   67|    509|  if (length > s_maxDNSNameLength) {
  ------------------
  |  Branch (67:7): [True: 0, False: 509]
  ------------------
   68|      0|    length = s_maxDNSNameLength;
   69|      0|    dots = "...";
   70|      0|  }
   71|    509|  std::string label;
   72|    509|  DNSName::appendEscapedLabel(label, content.begin(), length);
   73|    509|  throw std::range_error(msg + label + dots);
   74|    509|}
_ZN7DNSNameC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   77|  14.1k|{
   78|  14.1k|  if (content.empty() || (content.size() == 1 && content.at(0) == '.')) {
  ------------------
  |  Branch (78:7): [True: 0, False: 14.1k]
  |  Branch (78:27): [True: 7.22k, False: 6.95k]
  |  Branch (78:50): [True: 7.22k, False: 2]
  ------------------
   79|  7.22k|    d_storage.assign(1U, '\0');
   80|  7.22k|    return;
   81|  7.22k|  }
   82|       |
   83|  6.95k|  if (std::memchr(content.data(), '\\', content.size()) != nullptr) {
  ------------------
  |  Branch (83:7): [True: 0, False: 6.95k]
  ------------------
   84|      0|    d_storage = segmentDNSNameRaw(content.data(), content.size());
   85|      0|    if (d_storage.size() > s_maxDNSNameLength) {
  ------------------
  |  Branch (85:9): [True: 0, False: 0]
  ------------------
   86|      0|      throwSafeRangeError("name too long: ", content);
   87|      0|    }
   88|      0|    return;
   89|      0|  }
   90|       |
   91|  6.95k|  unsigned char lenpos = 0;
   92|  6.95k|  unsigned char labellen = 0;
   93|       |
   94|  6.95k|  d_storage.reserve(content.size() + 1U);
   95|  25.1k|  for (size_t position = 0; position < content.size(); ) {
  ------------------
  |  Branch (95:29): [True: 18.1k, False: 6.95k]
  ------------------
   96|  18.1k|    lenpos = d_storage.size();
   97|  18.1k|    if (content.at(position) == '.') {
  ------------------
  |  Branch (97:9): [True: 509, False: 17.6k]
  ------------------
   98|    509|      throwSafeRangeError("Found . in wrong position in DNSName: ", content);
   99|    509|    }
  100|  18.1k|    d_storage.append(1U, '\0');
  101|  18.1k|    labellen = 0;
  102|  18.1k|    size_t begPosition = position;
  103|   118k|    for(; position < content.size() && content.at(position) != '.'; ++position) {
  ------------------
  |  Branch (103:11): [True: 117k, False: 535]
  |  Branch (103:40): [True: 100k, False: 17.6k]
  ------------------
  104|   100k|      labellen++;
  105|   100k|    }
  106|       |    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  107|  18.1k|    d_storage.append(content.begin() + begPosition, content.begin() + position);
  108|  18.1k|    if (position < content.size()) {
  ------------------
  |  Branch (108:9): [True: 17.6k, False: 535]
  ------------------
  109|  17.6k|      ++position;
  110|  17.6k|    }
  111|  18.1k|    if (labellen > s_maxDNSLabelLength) {
  ------------------
  |  Branch (111:9): [True: 0, False: 18.1k]
  ------------------
  112|      0|      throwSafeRangeError("label too long to append: ", content);
  113|      0|    }
  114|       |
  115|  18.1k|    if (position > s_maxDNSNameLength - 1U) {
  ------------------
  |  Branch (115:9): [True: 0, False: 18.1k]
  ------------------
  116|       |      // reserve two bytes, one for length and one for the root label
  117|      0|      throwSafeRangeError("name too long to append: ", content);
  118|      0|    }
  119|       |
  120|  18.1k|    d_storage.at(lenpos) = static_cast<char>(labellen);
  121|  18.1k|  }
  122|  6.95k|  if (d_storage.size() > s_maxDNSNameLength - 1U) {
  ------------------
  |  Branch (122:7): [True: 0, False: 6.95k]
  ------------------
  123|      0|    throwSafeRangeError("name too long: ", content);
  124|      0|  }
  125|  6.95k|  d_storage.append(1U, '\0');
  126|  6.95k|}
_ZN7DNSNameC2EPKcmmbPtS2_PjtPm:
  129|  16.8k|{
  130|  16.8k|  if (offset >= len)
  ------------------
  |  Branch (130:7): [True: 70, False: 16.7k]
  ------------------
  131|     70|    throw std::range_error("Trying to read past the end of the buffer ("+std::to_string(offset)+ " >= "+std::to_string(len)+")");
  132|       |
  133|  16.7k|  if(!uncompress) {
  ------------------
  |  Branch (133:6): [True: 0, False: 16.7k]
  ------------------
  134|      0|    if(const void * fnd=memchr(pos+offset, 0, len-offset)) {
  ------------------
  |  Branch (134:21): [True: 0, False: 0]
  ------------------
  135|      0|      d_storage.reserve(2+(const char*)fnd-(pos+offset));
  136|      0|    }
  137|      0|  }
  138|       |
  139|  16.7k|  packetParser(pos, len, offset, uncompress, qtype, qclass, consumed, 0, minOffset, 0, pointerBudget);
  140|  16.7k|}
_ZN7DNSName23parsePacketUncompressedERKN4pdns5views16UnsignedCharViewEmb:
  154|  21.6k|{
  155|  21.6k|  const size_t initialPos = pos;
  156|  21.6k|  auto existingSize = d_storage.size();
  157|  21.6k|  const size_t neededSizeForFinalLabel = /* final empty label length */ (existingSize == 0 ? 1U : 0U);
  ------------------
  |  Branch (157:74): [True: 18.7k, False: 2.88k]
  ------------------
  158|  21.6k|  size_t totalLength = 0;
  159|  21.6k|  unsigned char labellen = 0;
  160|       |
  161|  39.9k|  do {
  162|  39.9k|    labellen = view.at(pos);
  163|  39.9k|    ++pos;
  164|       |
  165|  39.9k|    if (labellen == 0) {
  ------------------
  |  Branch (165:9): [True: 16.6k, False: 23.3k]
  ------------------
  166|  16.6k|      --pos;
  167|  16.6k|      break;
  168|  16.6k|    }
  169|       |
  170|  23.3k|    if (labellen >= 0xc0) {
  ------------------
  |  Branch (170:9): [True: 4.98k, False: 18.3k]
  ------------------
  171|  4.98k|      if (!uncompress) {
  ------------------
  |  Branch (171:11): [True: 0, False: 4.98k]
  ------------------
  172|      0|        throw std::range_error("Found compressed label, instructed not to follow");
  173|      0|      }
  174|  4.98k|      --pos;
  175|  4.98k|      break;
  176|  4.98k|    }
  177|       |
  178|  18.3k|    if ((labellen & 0xc0) != 0) {
  ------------------
  |  Branch (178:9): [True: 27, False: 18.3k]
  ------------------
  179|     27|      throw std::range_error("Found an invalid label length in qname (only one of the first two bits is set)");
  180|     27|    }
  181|  18.3k|    checkLabelLength(labellen);
  182|       |
  183|       |    // reserve one byte for the label length, plus one byte for the final empty label if we were empty before
  184|  18.3k|    if ((existingSize + totalLength + labellen + 1U + neededSizeForFinalLabel) > s_maxDNSNameLength) {
  ------------------
  |  Branch (184:9): [True: 2, False: 18.3k]
  ------------------
  185|      2|      throw std::range_error("name too long to append");
  186|      2|    }
  187|  18.3k|    if (pos + labellen >= view.size()) {
  ------------------
  |  Branch (187:9): [True: 19, False: 18.2k]
  ------------------
  188|     19|      throw std::range_error("Found an invalid label length in qname");
  189|     19|    }
  190|  18.2k|    pos += labellen;
  191|  18.2k|    totalLength += 1U + labellen;
  192|  18.2k|  }
  193|  21.6k|  while (pos < view.size());
  ------------------
  |  Branch (193:10): [True: 18.2k, False: 0]
  ------------------
  194|       |
  195|  21.6k|  if (totalLength != 0) {
  ------------------
  |  Branch (195:7): [True: 9.42k, False: 12.1k]
  ------------------
  196|  9.42k|    if (existingSize > 0) {
  ------------------
  |  Branch (196:9): [True: 2.85k, False: 6.57k]
  ------------------
  197|       |      // remove the last label count, we are about to override it */
  198|  2.85k|      --existingSize;
  199|  2.85k|    }
  200|  9.42k|    if ((existingSize + totalLength + 1U) > s_maxDNSNameLength) {
  ------------------
  |  Branch (200:9): [True: 0, False: 9.42k]
  ------------------
  201|      0|      throw std::range_error("name too long to append");
  202|      0|    }
  203|  9.42k|    d_storage.reserve(existingSize + totalLength + 1);
  204|  9.42k|    d_storage.resize(existingSize + totalLength);
  205|  9.42k|    memcpy(&d_storage.at(existingSize), &view.at(initialPos), totalLength);
  206|  9.42k|    d_storage.append(1, static_cast<char>(0));
  207|  9.42k|  }
  208|  21.6k|  return pos;
  209|  21.6k|}
_ZN7DNSName12packetParserEPKcmmbPtS2_PjittPm:
  213|  21.6k|{
  214|  21.6k|  if (offset >= len) {
  ------------------
  |  Branch (214:7): [True: 0, False: 21.6k]
  ------------------
  215|      0|    throw std::range_error("Trying to read past the end of the buffer ("+std::to_string(offset)+ " >= "+std::to_string(len)+")");
  216|      0|  }
  217|       |
  218|  21.6k|  if (offset < static_cast<size_t>(minOffset)) {
  ------------------
  |  Branch (218:7): [True: 0, False: 21.6k]
  ------------------
  219|      0|    throw std::range_error("Trying to read before the beginning of the buffer ("+std::to_string(offset)+ " < "+std::to_string(minOffset)+")");
  220|      0|  }
  221|  21.6k|  unsigned char labellen{0};
  222|       |
  223|  21.6k|  pdns::views::UnsignedCharView view(qpos, len);
  224|  21.6k|  auto pos = parsePacketUncompressed(view, offset, uncompress);
  225|       |
  226|       |
  227|  21.6k|  labellen = view.at(pos);
  228|  21.6k|  if (pos == offset && labellen != 0) {
  ------------------
  |  Branch (228:7): [True: 12.1k, False: 9.47k]
  |  Branch (228:24): [True: 2.08k, False: 10.0k]
  ------------------
  229|       |    // It's a pointer
  230|  2.08k|    if (pointerBudget != nullptr) {
  ------------------
  |  Branch (230:9): [True: 2.08k, False: 0]
  ------------------
  231|  2.08k|      if (*pointerBudget == 0) {
  ------------------
  |  Branch (231:11): [True: 0, False: 2.08k]
  ------------------
  232|      0|        throw std::range_error("Too many compression pointers processed in packet");
  233|      0|      }
  234|  2.08k|      (*pointerBudget)--;
  235|  2.08k|    }
  236|       |    // Are we chasing a pointer chain already for this name?
  237|  2.08k|    if (pointerChainLength++ > s_maxPointersToPointers) {
  ------------------
  |  Branch (237:9): [True: 1, False: 2.08k]
  ------------------
  238|      1|      throw std::range_error("Too many pointer to pointers during decompression (" + std::to_string(pointerChainLength) + ")");
  239|      1|    }
  240|  2.08k|  }
  241|  19.5k|  else {
  242|  19.5k|    pointerChainLength = 0; // not an immediate pointer to pointer case any more
  243|  19.5k|  }
  244|  21.6k|  pos++;
  245|  21.6k|  if (labellen != 0 && pos < view.size()) {
  ------------------
  |  Branch (245:7): [True: 4.98k, False: 16.6k]
  |  Branch (245:24): [True: 4.92k, False: 57]
  ------------------
  246|  4.92k|    if (labellen < 0xc0) {
  ------------------
  |  Branch (246:9): [True: 0, False: 4.92k]
  ------------------
  247|      0|      throw std::range_error("Invalid label byte during decompression ("+std::to_string(labellen)+")");
  248|      0|    }
  249|       |
  250|  4.92k|    if (!uncompress) {
  ------------------
  |  Branch (250:9): [True: 0, False: 4.92k]
  ------------------
  251|      0|      throw std::range_error("Found compressed label, instructed not to follow");
  252|      0|    }
  253|       |
  254|  4.92k|    labellen &= (~0xc0);
  255|  4.92k|    size_t newpos = (labellen << 8) + view.at(pos);
  256|       |
  257|  4.92k|    if (newpos >= offset) {
  ------------------
  |  Branch (257:9): [True: 46, False: 4.87k]
  ------------------
  258|     46|      throw std::range_error("Found a forward reference during label decompression");
  259|     46|    }
  260|       |
  261|  4.87k|    if (newpos < minOffset) {
  ------------------
  |  Branch (261:9): [True: 5, False: 4.87k]
  ------------------
  262|      5|      throw std::range_error("Invalid label position during decompression ("+std::to_string(newpos)+ " < "+std::to_string(minOffset)+")");
  263|      5|    }
  264|       |
  265|  4.87k|    if (++depth > s_maxPointersPerName) {
  ------------------
  |  Branch (265:9): [True: 1, False: 4.87k]
  ------------------
  266|      1|      throw std::range_error("Abort label decompression after too many redirects (" + std::to_string(depth) + ")");
  267|      1|    }
  268|       |
  269|  4.87k|    packetParser(qpos, len, newpos, true, nullptr, nullptr, nullptr, depth, minOffset, pointerChainLength, pointerBudget);
  270|       |
  271|  4.87k|    pos++;
  272|  4.87k|  }
  273|       |
  274|  21.6k|  if (d_storage.empty()) {
  ------------------
  |  Branch (274:7): [True: 10.1k, False: 11.4k]
  ------------------
  275|  10.1k|    d_storage.append(1, static_cast<char>(0)); // we just parsed the root
  276|  10.1k|  }
  277|       |
  278|  21.6k|  if (consumed != nullptr) {
  ------------------
  |  Branch (278:7): [True: 16.6k, False: 4.92k]
  ------------------
  279|  16.6k|    *consumed = pos - offset;
  280|  16.6k|  }
  281|       |
  282|  21.6k|  if (qtype != nullptr) {
  ------------------
  |  Branch (282:7): [True: 0, False: 21.6k]
  ------------------
  283|      0|    if (pos + 2 > view.size()) {
  ------------------
  |  Branch (283:9): [True: 0, False: 0]
  ------------------
  284|      0|      throw std::range_error("Trying to read qtype past the end of the buffer ("+std::to_string(pos + 2)+ " > "+std::to_string(len)+")");
  285|      0|    }
  286|      0|    *qtype = view.at(pos)*256 + view.at(pos+1);
  287|      0|  }
  288|       |
  289|  21.6k|  pos += 2;
  290|  21.6k|  if (qclass != nullptr) {
  ------------------
  |  Branch (290:7): [True: 0, False: 21.6k]
  ------------------
  291|      0|    if (pos + 2 > view.size()) {
  ------------------
  |  Branch (291:9): [True: 0, False: 0]
  ------------------
  292|      0|      throw std::range_error("Trying to read qclass past the end of the buffer ("+std::to_string(pos + 2)+ " > "+std::to_string(len)+")");
  293|      0|    }
  294|      0|    *qclass = view.at(pos)*256 + view.at(pos+1);
  295|      0|  }
  296|  21.6k|}
_ZNK7DNSName10wirelengthEv:
  367|  4.22k|size_t DNSName::wirelength() const {
  368|  4.22k|  return d_storage.length();
  369|  4.22k|}
_ZN7DNSName18appendEscapedLabelERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEPKcm:
  723|    509|{
  724|    509|  size_t pos = 0;
  725|       |
  726|  7.47k|  while (pos < len) {
  ------------------
  |  Branch (726:10): [True: 6.96k, False: 509]
  ------------------
  727|  6.96k|    auto p = static_cast<uint8_t>(orig[pos]);
  728|  6.96k|    if (p=='.') {
  ------------------
  |  Branch (728:9): [True: 1.01k, False: 5.95k]
  ------------------
  729|  1.01k|      appendTo+="\\.";
  730|  1.01k|    }
  731|  5.95k|    else if (p=='\\') {
  ------------------
  |  Branch (731:14): [True: 0, False: 5.95k]
  ------------------
  732|      0|      appendTo+="\\\\";
  733|      0|    }
  734|  5.95k|    else if (p > 0x20 && p < 0x7f) {
  ------------------
  |  Branch (734:14): [True: 5.95k, False: 0]
  |  Branch (734:26): [True: 5.95k, False: 0]
  ------------------
  735|  5.95k|      appendTo.append(1, static_cast<char>(p));
  736|  5.95k|    }
  737|      0|    else {
  738|      0|      char buf[] = "000";
  739|      0|      auto got = snprintf(buf, sizeof(buf), "%03" PRIu8, p);
  740|      0|      if (got < 0 || static_cast<size_t>(got) >= sizeof(buf)) {
  ------------------
  |  Branch (740:11): [True: 0, False: 0]
  |  Branch (740:22): [True: 0, False: 0]
  ------------------
  741|      0|        throw std::runtime_error("Error, snprintf returned " + std::to_string(got) + " while escaping label " + std::string(orig, len));
  742|      0|      }
  743|      0|      appendTo.append(1, '\\');
  744|      0|      appendTo += buf;
  745|      0|    }
  746|  6.96k|    ++pos;
  747|  6.96k|  }
  748|    509|}
_ZN8ZoneName20findVariantSeparatorENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  939|      2|{
  940|      2|  std::string_view::size_type pos{0};
  941|       |
  942|       |  // Try to be as fast as possible in the non-variant case and exit
  943|       |  // quickly if we don't find two dots in a row.
  944|      2|  while ((pos = name.find('.', pos)) != std::string_view::npos) {
  ------------------
  |  Branch (944:10): [True: 2, False: 0]
  ------------------
  945|      2|    ++pos;
  946|      2|    if (pos >= name.length()) { // trailing single dot
  ------------------
  |  Branch (946:9): [True: 2, False: 0]
  ------------------
  947|      2|      return std::string_view::npos;
  948|      2|    }
  949|      0|    if (name.at(pos) == '.') {
  ------------------
  |  Branch (949:9): [True: 0, False: 0]
  ------------------
  950|       |      // We have found two dots in a row, but the first dot might have been
  951|       |      // escaped. So we now need to count how many \ characters we can find a
  952|       |      // row before it; if their number is odd, the first dot is escaped and
  953|       |      // we need to keep searching.
  954|      0|      size_t slashes{0};
  955|      0|      while (pos >= 2 + slashes && name.at(pos - 2 - slashes) == '\\') {
  ------------------
  |  Branch (955:14): [True: 0, False: 0]
  |  Branch (955:36): [True: 0, False: 0]
  ------------------
  956|      0|        ++slashes;
  957|      0|      }
  958|      0|      if ((slashes % 2) == 0) {
  ------------------
  |  Branch (958:11): [True: 0, False: 0]
  ------------------
  959|      0|        break;
  960|      0|      }
  961|      0|    }
  962|      0|  }
  963|      0|  return pos;
  964|      2|}
_ZN8ZoneNameC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  967|      2|{
  968|      2|  if (auto sep = findVariantSeparator(name); sep != std::string_view::npos) {
  ------------------
  |  Branch (968:46): [True: 0, False: 2]
  ------------------
  969|      0|    setVariant(name.substr(sep + 1)); // ignore leading dot in variant name
  970|      0|    name = name.substr(0, sep); // keep trailing dot in zone name
  971|      0|  }
  972|      2|  d_name = DNSName(name);
  973|      2|}
dnsname.cc:_ZL16checkLabelLengthh:
  143|  18.3k|{
  144|  18.3k|  if (length == 0) {
  ------------------
  |  Branch (144:7): [True: 0, False: 18.3k]
  ------------------
  145|      0|    throw std::range_error("no such thing as an empty label to append");
  146|      0|  }
  147|  18.3k|  if (length > DNSName::s_maxDNSLabelLength) {
  ------------------
  |  Branch (147:7): [True: 0, False: 18.3k]
  ------------------
  148|      0|    throw std::range_error("label too long to append");
  149|      0|  }
  150|  18.3k|}

_Z11dns_tolowerh:
   58|  1.05k|{
   59|  1.05k|  return dns_tolower_table[chr];
   60|  1.05k|}
_Z39pdns_ilexicographical_compare_three_wayNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_:
   64|  10.7k|{
   65|  10.7k|  const unsigned char *aPtr = (const unsigned char*)a.data(), *bPtr = (const unsigned char*)b.data();
   66|  10.7k|  const unsigned char *aEptr = aPtr + a.length(), *bEptr = bPtr + b.length();
   67|  54.8k|  while(aPtr != aEptr && bPtr != bEptr) {
  ------------------
  |  Branch (67:9): [True: 44.5k, False: 10.2k]
  |  Branch (67:26): [True: 44.5k, False: 0]
  ------------------
   68|  44.5k|    if (*aPtr != *bPtr) {
  ------------------
  |  Branch (68:9): [True: 529, False: 44.0k]
  ------------------
   69|    529|      if (int rc = dns_tolower(*aPtr) - dns_tolower(*bPtr); rc != 0) {
  ------------------
  |  Branch (69:61): [True: 529, False: 0]
  ------------------
   70|    529|        return rc;
   71|    529|      }
   72|    529|    }
   73|  44.0k|    aPtr++;
   74|  44.0k|    bPtr++;
   75|  44.0k|  }
   76|       |  // At this point, one of the strings has been completely processed.
   77|       |  // Either both have the same length, and they are equal, or one of them
   78|       |  // is larger, and compares as higher.
   79|  10.2k|  if (aPtr == aEptr) {
  ------------------
  |  Branch (79:7): [True: 10.2k, False: 0]
  ------------------
   80|  10.2k|    if (bPtr != bEptr) {
  ------------------
  |  Branch (80:9): [True: 0, False: 10.2k]
  ------------------
   81|      0|      return -1; // a < b
   82|      0|    }
   83|  10.2k|  }
   84|      0|  else {
   85|      0|    return 1; // a > b
   86|      0|  }
   87|  10.2k|  return 0; // a == b
   88|  10.2k|}
_ZN7DNSNameaSERKS_:
  151|    509|  {
  152|    509|    if (this != &rhs) {
  ------------------
  |  Branch (152:9): [True: 509, False: 0]
  ------------------
  153|    509|      d_storage = rhs.d_storage;
  154|    509|    }
  155|    509|    return *this;
  156|    509|  }
_ZN7DNSNameaSEOS_:
  158|  26.0k|  {
  159|  26.0k|    if (this != &rhs) {
  ------------------
  |  Branch (159:9): [True: 26.0k, False: 0]
  ------------------
  160|  26.0k|      d_storage = std::move(rhs.d_storage);
  161|  26.0k|    }
  162|  26.0k|    return *this;
  163|  26.0k|  }
_ZNK7DNSName5emptyEv:
  210|  27.8k|  bool empty() const { return d_storage.empty(); }
_ZNK7DNSName6isRootEv:
  211|  24.9k|  bool isRoot() const { return d_storage.size()==1 && d_storage[0]==0; }
  ------------------
  |  Branch (211:32): [True: 12.1k, False: 12.8k]
  |  Branch (211:55): [True: 12.1k, False: 0]
  ------------------
_ZNK7DNSName10getStorageEv:
  261|  12.8k|  const string_t& getStorage() const {
  262|  12.8k|    return d_storage;
  263|  12.8k|  }
_ZNK7DNSNameeqERKS_:
  826|  6.41k|{
  827|  6.41k|  if (rhs.empty() != empty() || rhs.d_storage.size() != d_storage.size()) {
  ------------------
  |  Branch (827:7): [True: 0, False: 6.41k]
  |  Branch (827:33): [True: 6.41k, False: 0]
  ------------------
  828|  6.41k|    return false;
  829|  6.41k|  }
  830|       |
  831|      0|  const auto* us = d_storage.cbegin();
  832|      0|  const auto* p = rhs.d_storage.cbegin();
  833|      0|  for (; us != d_storage.cend() && p != rhs.d_storage.cend(); ++us, ++p) {
  ------------------
  |  Branch (833:10): [True: 0, False: 0]
  |  Branch (833:36): [True: 0, False: 0]
  ------------------
  834|      0|    if (dns_tolower(*p) != dns_tolower(*us)) {
  ------------------
  |  Branch (834:9): [True: 0, False: 0]
  ------------------
  835|      0|      return false;
  836|      0|    }
  837|      0|  }
  838|      0|  return true;
  839|      0|}
_ZN7DNSNameC2ERKS_:
  164|  5.86k|  DNSName(const DNSName& a) = default;
_ZN7DNSNameC2Ev:
  148|  26.9k|  DNSName() = default; //!< Constructs an *empty* DNSName, NOT the root!
_ZN7DNSNameC2EOS_:
  165|  7.67k|  DNSName(DNSName&& a) = default;

_ZN16DNSRecordContent4makeERK9DNSRecordR12PacketReadert:
  259|  9.29k|{
  260|       |  // For opcode UPDATE and where the DNSRecord is an answer record, we don't care about content, because this is
  261|       |  // not used within the prerequisite section of RFC2136, so - we can simply use unknownrecordcontent.
  262|       |  // For section 3.2.3, we do need content so we need to get it properly. But only for the correct QClasses.
  263|  9.29k|  if (oc == Opcode::Update && dr.d_place == DNSResourceRecord::ANSWER && dr.d_class != 1)
  ------------------
  |  Branch (263:7): [True: 0, False: 9.29k]
  |  Branch (263:31): [True: 0, False: 0]
  |  Branch (263:74): [True: 0, False: 0]
  ------------------
  264|      0|    return std::make_shared<UnknownRecordContent>(dr, pr);
  265|       |
  266|  9.29k|  uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT
  ------------------
  |  Branch (266:26): [True: 592, False: 8.70k]
  ------------------
  267|       |
  268|  9.29k|  auto i = getTypemap().find(pair(searchclass, dr.d_type));
  269|  9.29k|  if(i==getTypemap().end() || !i->second) {
  ------------------
  |  Branch (269:6): [True: 1.64k, False: 7.65k]
  |  Branch (269:6): [True: 1.64k, False: 7.65k]
  |  Branch (269:31): [True: 0, False: 7.65k]
  ------------------
  270|  1.64k|    return std::make_shared<UnknownRecordContent>(dr, pr);
  271|  1.64k|  }
  272|       |
  273|  7.65k|  return i->second(dr, pr);
  274|  9.29k|}
_ZN16DNSRecordContent10getTypemapEv:
  284|  18.7k|{
  285|  18.7k|  static DNSRecordContent::typemap_t typemap;
  286|  18.7k|  return typemap;
  287|  18.7k|}
_ZN16DNSRecordContent12getN2TypemapEv:
  290|    118|{
  291|    118|  static DNSRecordContent::n2typemap_t n2typemap;
  292|    118|  return n2typemap;
  293|    118|}
_ZN16DNSRecordContent12getT2NamemapEv:
  296|    118|{
  297|    118|  static DNSRecordContent::t2namemap_t t2namemap;
  298|    118|  return t2namemap;
  299|    118|}
_ZN16DNSRecordContent12getZmakermapEv:
  302|    115|{
  303|    115|  static DNSRecordContent::zmakermap_t zmakermap;
  304|    115|  return zmakermap;
  305|    115|}
_ZN12MOADNSParser4initEbRKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEm:
  336|  4.16k|{
  337|  4.16k|  if (packet.size() < sizeof(dnsheader))
  ------------------
  |  Branch (337:7): [True: 0, False: 4.16k]
  ------------------
  338|      0|    throw MOADNSException("Packet shorter than minimal header");
  339|       |
  340|  4.16k|  memcpy(&d_header, packet.data(), sizeof(dnsheader));
  341|       |
  342|  4.16k|  if(d_header.opcode != Opcode::Query && d_header.opcode != Opcode::Notify && d_header.opcode != Opcode::Update)
  ------------------
  |  Branch (342:6): [True: 0, False: 4.16k]
  |  Branch (342:42): [True: 0, False: 0]
  |  Branch (342:79): [True: 0, False: 0]
  ------------------
  343|      0|    throw MOADNSException("Can't parse non-query packet with opcode="+ std::to_string(d_header.opcode));
  344|       |
  345|  4.16k|  d_header.qdcount=ntohs(d_header.qdcount);
  346|  4.16k|  d_header.ancount=ntohs(d_header.ancount);
  347|  4.16k|  d_header.nscount=ntohs(d_header.nscount);
  348|  4.16k|  d_header.arcount=ntohs(d_header.arcount);
  349|       |
  350|  4.16k|  if (query && (d_header.qdcount > 1))
  ------------------
  |  Branch (350:7): [True: 0, False: 4.16k]
  |  Branch (350:16): [True: 0, False: 0]
  ------------------
  351|      0|    throw MOADNSException("Query with QD > 1 ("+std::to_string(d_header.qdcount)+")");
  352|       |
  353|  4.16k|  unsigned int n=0;
  354|       |
  355|  4.16k|  PacketReader pr(packet);
  356|  4.16k|  if (pointerBudget != 0) {
  ------------------
  |  Branch (356:7): [True: 0, False: 4.16k]
  ------------------
  357|      0|    pr.setPointerBudget(pointerBudget);
  358|      0|  }
  359|  4.16k|  bool validPacket=false;
  360|  4.16k|  try {
  361|  4.16k|    d_qtype = d_qclass = 0; // sometimes replies come in with no question, don't present garbage then
  362|       |
  363|  8.32k|    for(n=0;n < d_header.qdcount; ++n) {
  ------------------
  |  Branch (363:13): [True: 4.16k, False: 4.16k]
  ------------------
  364|  4.16k|      d_qname=pr.getName();
  365|  4.16k|      d_qtype=pr.get16BitInt();
  366|  4.16k|      d_qclass=pr.get16BitInt();
  367|  4.16k|    }
  368|       |
  369|  4.16k|    struct dnsrecordheader ah;
  370|  4.16k|    vector<unsigned char> record;
  371|  4.16k|    bool seenTSIG = false;
  372|  4.16k|    validPacket=true;
  373|  4.16k|    unsigned int supposedRecordCount = d_header.ancount + d_header.nscount + d_header.arcount;
  374|       |    // No need to reserve more memory for more records than the request can
  375|       |    // contain. We could try to be smarter and actually count the records
  376|       |    // by doing getDnsrecordheader and skip the payload in a loop, but all
  377|       |    // we really want here is to avoid reserving too much memory in case of
  378|       |    // maliciously high record counts.
  379|  4.16k|    auto reserveRecordCount = std::min(1 + (packet.size() - sizeof(dnsheader)) / sizeof(dnsrecordheader), static_cast<size_t>(supposedRecordCount));
  380|  4.16k|    d_answers.reserve(reserveRecordCount);
  381|  13.4k|    for (n = 0; n < supposedRecordCount; ++n) {
  ------------------
  |  Branch (381:17): [True: 9.29k, False: 4.16k]
  ------------------
  382|  9.29k|      DNSRecord dr;
  383|       |
  384|  9.29k|      if(n < d_header.ancount)
  ------------------
  |  Branch (384:10): [True: 8.74k, False: 550]
  ------------------
  385|  8.74k|        dr.d_place=DNSResourceRecord::ANSWER;
  386|    550|      else if(n < d_header.ancount + d_header.nscount)
  ------------------
  |  Branch (386:15): [True: 0, False: 550]
  ------------------
  387|      0|        dr.d_place=DNSResourceRecord::AUTHORITY;
  388|    550|      else
  389|    550|        dr.d_place=DNSResourceRecord::ADDITIONAL;
  390|       |
  391|  9.29k|      unsigned int recordStartPos=pr.getPosition();
  392|       |
  393|  9.29k|      DNSName name=pr.getName();
  394|       |
  395|  9.29k|      pr.getDnsrecordheader(ah);
  396|  9.29k|      dr.d_ttl=ah.d_ttl;
  397|  9.29k|      dr.d_type=ah.d_type;
  398|  9.29k|      dr.d_class=ah.d_class;
  399|       |
  400|  9.29k|      dr.d_name = std::move(name);
  401|  9.29k|      dr.d_clen = ah.d_clen;
  402|       |
  403|  9.29k|      auto recordContentStartPos = pr.getPosition();
  404|       |
  405|  9.29k|      if (query &&
  ------------------
  |  Branch (405:11): [True: 0, False: 9.29k]
  ------------------
  406|      0|          !(d_qtype == QType::IXFR && dr.d_place == DNSResourceRecord::AUTHORITY && dr.d_type == QType::SOA) && // IXFR queries have a SOA in their AUTHORITY section
  ------------------
  |  Branch (406:13): [True: 0, False: 0]
  |  Branch (406:39): [True: 0, False: 0]
  |  Branch (406:85): [True: 0, False: 0]
  ------------------
  407|      0|          (dr.d_place == DNSResourceRecord::ANSWER || dr.d_place == DNSResourceRecord::AUTHORITY || (dr.d_type != QType::OPT && dr.d_type != QType::TSIG && dr.d_type != QType::SIG && dr.d_type != QType::TKEY) || ((dr.d_type == QType::TSIG || dr.d_type == QType::SIG || dr.d_type == QType::TKEY) && dr.d_class != QClass::ANY))) {
  ------------------
  |  Branch (407:12): [True: 0, False: 0]
  |  Branch (407:55): [True: 0, False: 0]
  |  Branch (407:102): [True: 0, False: 0]
  |  Branch (407:129): [True: 0, False: 0]
  |  Branch (407:157): [True: 0, False: 0]
  |  Branch (407:184): [True: 0, False: 0]
  |  Branch (407:215): [True: 0, False: 0]
  |  Branch (407:243): [True: 0, False: 0]
  |  Branch (407:270): [True: 0, False: 0]
  |  Branch (407:299): [True: 0, False: 0]
  ------------------
  408|       |//        cerr<<"discarding RR, query is "<<query<<", place is "<<dr.d_place<<", type is "<<dr.d_type<<", class is "<<dr.d_class<<endl;
  409|      0|        dr.setContent(std::make_shared<UnknownRecordContent>(dr, pr));
  410|      0|      }
  411|  9.29k|      else {
  412|       |//        cerr<<"parsing RR, query is "<<query<<", place is "<<dr.d_place<<", type is "<<dr.d_type<<", class is "<<dr.d_class<<endl;
  413|  9.29k|        dr.setContent(DNSRecordContent::make(dr, pr, d_header.opcode));
  414|  9.29k|      }
  415|       |
  416|  9.29k|      if (dr.d_place == DNSResourceRecord::ADDITIONAL && seenTSIG) {
  ------------------
  |  Branch (416:11): [True: 550, False: 8.74k]
  |  Branch (416:58): [True: 0, False: 550]
  ------------------
  417|      0|        throw MOADNSException("Packet ("+d_qname.toString()+"|#"+std::to_string(d_qtype)+") has an unexpected record ("+std::to_string(dr.d_type)+") after a TSIG one.");
  418|      0|      }
  419|       |
  420|  9.29k|      if(dr.d_type == QType::TSIG && dr.d_class == QClass::ANY) {
  ------------------
  |  Branch (420:10): [True: 24, False: 9.27k]
  |  Branch (420:38): [True: 0, False: 24]
  ------------------
  421|      0|        if(seenTSIG || dr.d_place != DNSResourceRecord::ADDITIONAL) {
  ------------------
  |  Branch (421:12): [True: 0, False: 0]
  |  Branch (421:24): [True: 0, False: 0]
  ------------------
  422|      0|          throw MOADNSException("Packet ("+d_qname.toLogString()+"|#"+std::to_string(d_qtype)+") has a TSIG record in an invalid position.");
  423|      0|        }
  424|      0|        seenTSIG = true;
  425|      0|        d_tsigPos = recordStartPos;
  426|      0|      }
  427|       |
  428|  9.29k|      if (pr.getPosition() != recordContentStartPos + ah.d_clen) {
  ------------------
  |  Branch (428:11): [True: 0, False: 9.29k]
  ------------------
  429|      0|        throw MOADNSException("Packet ("+d_qname.toLogString()+"|#"+std::to_string(d_qtype)+") has a record content that does not end on the record boundary");
  430|      0|      }
  431|       |
  432|  9.29k|      d_answers.emplace_back(std::move(dr));
  433|  9.29k|    }
  434|       |
  435|       |#if 0
  436|       |    if(pr.getPosition()!=packet.size()) {
  437|       |      throw MOADNSException("Packet ("+d_qname+"|#"+std::to_string(d_qtype)+") has trailing garbage ("+ std::to_string(pr.getPosition()) + " < " +
  438|       |                            std::to_string(packet.size()) + ")");
  439|       |    }
  440|       |#endif
  441|  4.16k|  }
  442|  4.16k|  catch(const std::out_of_range &re) {
  443|  1.13k|    if(validPacket && d_header.tc) { // don't sweat it over truncated packets, but do adjust an, ns and arcount
  ------------------
  |  Branch (443:8): [True: 1.13k, False: 0]
  |  Branch (443:23): [True: 0, False: 1.13k]
  ------------------
  444|      0|      if(n < d_header.ancount) {
  ------------------
  |  Branch (444:10): [True: 0, False: 0]
  ------------------
  445|      0|        d_header.ancount=n; d_header.nscount = d_header.arcount = 0;
  446|      0|      }
  447|      0|      else if(n < d_header.ancount + d_header.nscount) {
  ------------------
  |  Branch (447:15): [True: 0, False: 0]
  ------------------
  448|      0|        d_header.nscount = n - d_header.ancount; d_header.arcount=0;
  449|      0|      }
  450|      0|      else {
  451|      0|        d_header.arcount = n - d_header.ancount - d_header.nscount;
  452|      0|      }
  453|      0|    }
  454|  1.13k|    else {
  455|  1.13k|      throw MOADNSException("Error parsing packet of "+std::to_string(packet.size())+" bytes (rd="+
  456|  1.13k|                            std::to_string(d_header.rd)+
  457|  1.13k|                            "), out of bounds: "+string(re.what()));
  458|  1.13k|    }
  459|  1.13k|  }
  460|  4.16k|}
_ZN12PacketReader18getDnsrecordheaderER15dnsrecordheader:
  480|  9.29k|{
  481|  9.29k|  unsigned char *p = reinterpret_cast<unsigned char*>(&ah);
  482|       |
  483|   102k|  for(unsigned int n = 0; n < sizeof(dnsrecordheader); ++n) {
  ------------------
  |  Branch (483:27): [True: 92.9k, False: 9.29k]
  ------------------
  484|  92.9k|    p[n] = d_content.at(d_pos++);
  485|  92.9k|  }
  486|       |
  487|  9.29k|  ah.d_type = ntohs(ah.d_type);
  488|  9.29k|  ah.d_class = ntohs(ah.d_class);
  489|  9.29k|  ah.d_clen = ntohs(ah.d_clen);
  490|  9.29k|  ah.d_ttl = ntohl(ah.d_ttl);
  491|       |
  492|  9.29k|  d_startrecordpos = d_pos; // needed for getBlob later on
  493|  9.29k|  d_recordlen = ah.d_clen;
  494|  9.29k|  if (d_pos > d_content.size() || (d_content.size() - d_pos) < (d_recordlen)) {
  ------------------
  |  Branch (494:7): [True: 0, False: 9.29k]
  |  Branch (494:35): [True: 0, False: 9.29k]
  ------------------
  495|      0|    throw std::out_of_range("DNS record length (" + std::to_string(d_recordlen) + " starting at " + std::to_string(d_pos) + ") goes beyond the packet's content (" + std::to_string(d_content.size()) + ")");
  496|      0|  }
  497|  9.29k|}
_ZN12PacketReader10copyRecordERNSt3__16vectorIhNS0_9allocatorIhEEEEt:
  501|  1.64k|{
  502|  1.64k|  if (len == 0) {
  ------------------
  |  Branch (502:7): [True: 636, False: 1.00k]
  ------------------
  503|    636|    return;
  504|    636|  }
  505|  1.00k|  if ((d_pos + len) > d_content.size()) {
  ------------------
  |  Branch (505:7): [True: 0, False: 1.00k]
  ------------------
  506|      0|    throw std::out_of_range("Attempt to copy outside of packet");
  507|      0|  }
  508|  1.00k|  if (!isWithinRecordBoundaries(d_pos, d_pos + len)) {
  ------------------
  |  Branch (508:7): [True: 0, False: 1.00k]
  ------------------
  509|      0|    throw std::out_of_range("Attempt to copy outside of record");
  510|      0|  }
  511|       |
  512|  1.00k|  dest.resize(len);
  513|       |
  514|  3.32M|  for (uint16_t n = 0; n < len; ++n) {
  ------------------
  |  Branch (514:24): [True: 3.32M, False: 1.00k]
  ------------------
  515|  3.32M|    dest.at(n) = d_content.at(d_pos++);
  516|  3.32M|  }
  517|  1.00k|}
_ZN12PacketReader10copyRecordEPht:
  520|    109|{
  521|    109|  if (d_pos + len > d_content.size()) {
  ------------------
  |  Branch (521:7): [True: 0, False: 109]
  ------------------
  522|      0|    throw std::out_of_range("Attempt to copy outside of packet");
  523|      0|  }
  524|    109|  if (!isWithinRecordBoundaries(d_pos, d_pos + len)) {
  ------------------
  |  Branch (524:7): [True: 0, False: 109]
  ------------------
  525|      0|    throw std::out_of_range("Attempt to copy outside of record");
  526|      0|  }
  527|       |
  528|    109|  memcpy(dest, &d_content.at(d_pos), len);
  529|    109|  d_pos += len;
  530|    109|}
_ZN12PacketReader18xfrNodeOrLocatorIDER15NodeOrLocatorID:
  533|     98|{
  534|     98|  if (d_pos + sizeof(ret) > d_content.size()) {
  ------------------
  |  Branch (534:7): [True: 7, False: 91]
  ------------------
  535|      7|    throw std::out_of_range("Attempt to read 64 bit value outside of packet");
  536|      7|  }
  537|     91|  if (!isWithinRecordBoundaries(d_pos, d_pos + sizeof(ret))) {
  ------------------
  |  Branch (537:7): [True: 13, False: 78]
  ------------------
  538|     13|    throw std::out_of_range("Attempt to read node or locator ID outside of record");
  539|     13|  }
  540|       |
  541|     78|  memcpy(&ret.content, &d_content.at(d_pos), sizeof(ret.content));
  542|     78|  d_pos += sizeof(ret);
  543|     78|}
_ZN12PacketReader11get32BitIntEv:
  565|  1.58k|{
  566|  1.58k|  uint32_t ret=0;
  567|  1.58k|  if (!isWithinRecordBoundaries(d_pos, d_pos + sizeof(ret))) {
  ------------------
  |  Branch (567:7): [True: 93, False: 1.49k]
  ------------------
  568|     93|    throw std::out_of_range("Attempt to read 32 bit value outside of record");
  569|     93|  }
  570|  1.49k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  571|  1.49k|  ret<<=8;
  572|  1.49k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  573|  1.49k|  ret<<=8;
  574|  1.49k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  575|  1.49k|  ret<<=8;
  576|  1.49k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  577|       |
  578|  1.49k|  return ret;
  579|  1.58k|}
_ZN12PacketReader11get16BitIntEv:
  583|   237k|{
  584|   237k|  uint16_t ret=0;
  585|   237k|  if (!isWithinRecordBoundaries(d_pos, d_pos + sizeof(ret))) {
  ------------------
  |  Branch (585:7): [True: 262, False: 236k]
  ------------------
  586|    262|    throw std::out_of_range("Attempt to read 16 bit value outside of record");
  587|    262|  }
  588|   236k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  589|   236k|  ret<<=8;
  590|   236k|  ret+=static_cast<uint8_t>(d_content.at(d_pos++));
  591|       |
  592|   236k|  return ret;
  593|   237k|}
_ZN12PacketReader10get8BitIntEv:
  596|  68.2k|{
  597|  68.2k|  if (!isWithinRecordBoundaries(d_pos, d_pos + sizeof(uint8_t))) {
  ------------------
  |  Branch (597:7): [True: 125, False: 68.0k]
  ------------------
  598|    125|    throw std::out_of_range("Attempt to read 8 bit value outside of record");
  599|    125|  }
  600|  68.0k|  return d_content.at(d_pos++);
  601|  68.2k|}
_ZN12PacketReader7getNameEv:
  604|  16.8k|{
  605|  16.8k|  unsigned int consumed{0};
  606|  16.8k|  const auto initialPosition = d_pos;
  607|  16.8k|  try {
  608|  16.8k|    uint16_t minOffset = d_standalone ? 0 : sizeof(dnsheader);
  ------------------
  |  Branch (608:26): [True: 0, False: 16.8k]
  ------------------
  609|  16.8k|    bool uncompress = !d_standalone;
  610|       |
  611|  16.8k|    DNSName name((const char*) d_content.data(), d_content.size(), d_pos, uncompress, nullptr /* qtype */, nullptr /* qclass */, &consumed, minOffset, &d_pointerBudget);
  612|       |
  613|  16.8k|    d_pos += consumed;
  614|       |    // if we know the length of the record, and we were parsing a DNS name inside the record contents
  615|       |    // (not the owner name, in which case d_startrecordpos and d_recordlen still refer to the content of the previous record),
  616|       |    // check that we did not go over the record boundary
  617|  16.8k|    if (!isWithinRecordBoundaries(initialPosition, d_pos, true)) {
  ------------------
  |  Branch (617:9): [True: 25, False: 16.8k]
  ------------------
  618|     25|      throw std::out_of_range("Attempt to read DNS name outside of record");
  619|     25|    }
  620|  16.8k|    return name;
  621|  16.8k|  }
  622|  16.8k|  catch(const std::range_error& re) {
  623|    171|    throw std::out_of_range(string("dnsname issue: ")+re.what());
  624|    171|  }
  625|  16.8k|  catch(...) {
  626|     25|    throw std::out_of_range("dnsname issue");
  627|     25|  }
  628|  16.8k|}
_Z9txtEscapeRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  632|  27.0k|{
  633|  27.0k|  string ret;
  634|  27.0k|  ret.reserve(name.length()); // In the typical case no escaping is needed
  635|  27.0k|  std::array<char, 5> ebuf{};
  636|       |
  637|  1.04M|  for (char letter : name) {
  ------------------
  |  Branch (637:20): [True: 1.04M, False: 27.0k]
  ------------------
  638|  1.04M|    const unsigned uch = static_cast<unsigned char>(letter);
  639|  1.04M|    if (uch >= 127 || uch < 32) {
  ------------------
  |  Branch (639:9): [True: 202k, False: 845k]
  |  Branch (639:23): [True: 696k, False: 149k]
  ------------------
  640|   898k|      snprintf(ebuf.data(), ebuf.size(), "\\%03u", uch);
  641|   898k|      ret += ebuf.data();
  642|   898k|    }
  643|   149k|    else if (letter == '"' || letter == '\\'){
  ------------------
  |  Branch (643:14): [True: 2.15k, False: 147k]
  |  Branch (643:31): [True: 1.97k, False: 145k]
  ------------------
  644|  4.13k|      ret += '\\';
  645|  4.13k|      ret += letter;
  646|  4.13k|    }
  647|   145k|    else {
  648|   145k|      ret += letter;
  649|   145k|    }
  650|  1.04M|  }
  651|  27.0k|  return ret;
  652|  27.0k|}
_ZN12PacketReader7getTextEbb:
  656|  1.15k|{
  657|  1.15k|  string ret;
  658|  1.15k|  ret.reserve(40);
  659|   145k|  while (d_pos < d_startrecordpos + d_recordlen ) {
  ------------------
  |  Branch (659:10): [True: 144k, False: 852]
  ------------------
  660|   144k|    if (!ret.empty()) {
  ------------------
  |  Branch (660:9): [True: 143k, False: 871]
  ------------------
  661|   143k|      ret.append(1,' ');
  662|   143k|    }
  663|   144k|    uint16_t labellen;
  664|   144k|    if (lenField) {
  ------------------
  |  Branch (664:9): [True: 143k, False: 443]
  ------------------
  665|   143k|      labellen = static_cast<uint8_t>(d_content.at(d_pos++));
  666|   143k|    }
  667|    443|    else {
  668|    443|      labellen = d_recordlen - (d_pos - d_startrecordpos);
  669|    443|    }
  670|       |
  671|   144k|    const uint16_t remaining = (d_startrecordpos + d_recordlen) - d_pos;
  672|   144k|    if (labellen > remaining) {
  ------------------
  |  Branch (672:9): [True: 61, False: 144k]
  ------------------
  673|     61|      throw std::out_of_range("label length in text record exceeds record boundary");
  674|     61|    }
  675|       |
  676|   144k|    ret.append(1, '"');
  677|   144k|    if (labellen) { // no need to do anything for an empty string
  ------------------
  |  Branch (677:9): [True: 27.0k, False: 117k]
  ------------------
  678|  27.0k|      string val(&d_content.at(d_pos), &d_content.at(d_pos + labellen - 1) + 1);
  679|  27.0k|      ret.append(txtEscape(val)); // the end is one beyond the packet
  680|  27.0k|    }
  681|   144k|    ret.append(1, '"');
  682|   144k|    d_pos += labellen;
  683|   144k|    if (!multi) {
  ------------------
  |  Branch (683:9): [True: 243, False: 143k]
  ------------------
  684|    243|      break;
  685|    243|    }
  686|   144k|  }
  687|       |
  688|  1.09k|  if (ret.empty() && !lenField) {
  ------------------
  |  Branch (688:7): [True: 285, False: 810]
  |  Branch (688:22): [True: 110, False: 175]
  ------------------
  689|       |    // all lenField == false cases (CAA and URI at the time of this writing) want that emptiness to be explicit
  690|    110|    return "\"\"";
  691|    110|  }
  692|    985|  return ret;
  693|  1.09k|}
_ZN12PacketReader15getUnquotedTextEb:
  696|    515|{
  697|    515|  uint16_t stop_at{};
  698|    515|  if (lenField) {
  ------------------
  |  Branch (698:7): [True: 515, False: 0]
  ------------------
  699|    515|    stop_at = static_cast<uint8_t>(d_content.at(d_pos)) + d_pos + 1;
  700|    515|  }
  701|      0|  else {
  702|      0|    stop_at = d_recordlen;
  703|      0|  }
  704|       |
  705|       |  /* think unsigned overflow */
  706|    515|  if (stop_at < d_pos) {
  ------------------
  |  Branch (706:7): [True: 1, False: 514]
  ------------------
  707|      1|    throw std::out_of_range("getUnquotedText out of record range");
  708|      1|  }
  709|       |
  710|       |  /* Validate against record boundary */
  711|    514|  const uint16_t recordEnd = d_startrecordpos + d_recordlen;
  712|    514|  if (stop_at > recordEnd) {
  ------------------
  |  Branch (712:7): [True: 27, False: 487]
  ------------------
  713|     27|    throw std::out_of_range("getUnquotedText: length exceeds record boundary");
  714|     27|  }
  715|       |
  716|    487|  if (stop_at == d_pos) {
  ------------------
  |  Branch (716:7): [True: 0, False: 487]
  ------------------
  717|      0|    return "";
  718|      0|  }
  719|       |
  720|    487|  d_pos++;
  721|    487|  string ret(d_content.substr(d_pos, stop_at-d_pos));
  722|    487|  d_pos = stop_at;
  723|    487|  return ret;
  724|    487|}
_ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  727|  2.28k|{
  728|  2.28k|  try {
  729|  2.28k|    if (d_recordlen != 0 && !(d_pos == (d_startrecordpos + d_recordlen))) {
  ------------------
  |  Branch (729:9): [True: 1.96k, False: 312]
  |  Branch (729:29): [True: 1.58k, False: 386]
  ------------------
  730|  1.58k|      if (d_pos > (d_startrecordpos + d_recordlen)) {
  ------------------
  |  Branch (730:11): [True: 1, False: 1.58k]
  ------------------
  731|      1|        throw std::out_of_range("xfrBlob out of record range");
  732|      1|      }
  733|  1.58k|      blob.assign(&d_content.at(d_pos), &d_content.at(d_startrecordpos + d_recordlen - 1 ) + 1);
  734|  1.58k|    }
  735|    698|    else {
  736|    698|      blob.clear();
  737|    698|    }
  738|       |
  739|  2.28k|    d_pos = d_startrecordpos + d_recordlen;
  740|  2.28k|  }
  741|  2.28k|  catch(...)
  742|  2.28k|  {
  743|      1|    throw std::out_of_range("xfrBlob out of range");
  744|      1|  }
  745|  2.28k|}
_ZN12PacketReader15xfrBlobNoSpacesERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi:
  747|     33|void PacketReader::xfrBlobNoSpaces(string& blob, int length) {
  748|     33|  xfrBlob(blob, length);
  749|     33|}
_ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi:
  752|  47.1k|{
  753|  47.1k|  if(length) {
  ------------------
  |  Branch (753:6): [True: 46.6k, False: 509]
  ------------------
  754|  46.6k|    if (length < 0) {
  ------------------
  |  Branch (754:9): [True: 0, False: 46.6k]
  ------------------
  755|      0|      throw std::out_of_range("xfrBlob out of range (negative length)");
  756|      0|    }
  757|  46.6k|    auto available = (d_startrecordpos + d_recordlen) - d_pos;
  758|  46.6k|    if (available < length) {
  ------------------
  |  Branch (758:9): [True: 22, False: 46.6k]
  ------------------
  759|     22|      throw std::out_of_range("xfrBlob out of range (excessive length)");
  760|     22|    }
  761|       |
  762|  46.6k|    blob.assign(&d_content.at(d_pos), &d_content.at(d_pos + length - 1 ) + 1 );
  763|       |
  764|  46.6k|    d_pos += length;
  765|  46.6k|  }
  766|    509|  else {
  767|    509|    blob.clear();
  768|    509|  }
  769|  47.1k|}
_ZN12PacketReader18xfrSvcParamKeyValsERNSt3__13setI8SvcParamNS0_4lessIS2_EENS0_9allocatorIS2_EEEE:
  771|    927|void PacketReader::xfrSvcParamKeyVals(set<SvcParam> &kvs) {
  772|    927|  int32_t lastKey{-1}; // Keep track of the last key, as ordering should be strict
  773|       |
  774|  1.95k|  while (d_pos < (d_startrecordpos + d_recordlen)) {
  ------------------
  |  Branch (774:10): [True: 1.31k, False: 639]
  ------------------
  775|  1.31k|    if (d_pos + 2 > (d_startrecordpos + d_recordlen)) {
  ------------------
  |  Branch (775:9): [True: 24, False: 1.29k]
  ------------------
  776|     24|      throw std::out_of_range("incomplete key");
  777|     24|    }
  778|  1.29k|    uint16_t keyInt;
  779|  1.29k|    xfr16BitInt(keyInt);
  780|       |
  781|  1.29k|    if (keyInt <= lastKey) {
  ------------------
  |  Branch (781:9): [True: 50, False: 1.24k]
  ------------------
  782|     50|      throw std::out_of_range("Found SVCParamKey " + std::to_string(keyInt) + " after SVCParamKey " + std::to_string(lastKey));
  783|     50|    }
  784|  1.24k|    lastKey = keyInt;
  785|       |
  786|       |    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange): this is fine, we will handle that in the switch/case
  787|  1.24k|    auto key = static_cast<SvcParam::SvcParamKey>(keyInt);
  788|       |
  789|  1.24k|    uint16_t len;
  790|  1.24k|    xfr16BitInt(len);
  791|       |
  792|  1.24k|    if (d_pos + len > (d_startrecordpos + d_recordlen)) {
  ------------------
  |  Branch (792:9): [True: 68, False: 1.17k]
  ------------------
  793|     68|      throw std::out_of_range("record is shorter than SVCB lengthfield implies");
  794|     68|    }
  795|       |
  796|  1.17k|    switch (key)
  797|  1.17k|    {
  798|    184|    case SvcParam::mandatory: {
  ------------------
  |  Branch (798:5): [True: 184, False: 989]
  ------------------
  799|    184|      if (len % 2 != 0) {
  ------------------
  |  Branch (799:11): [True: 1, False: 183]
  ------------------
  800|      1|        throw std::out_of_range("mandatory SvcParam has invalid length");
  801|      1|      }
  802|    183|      if (len == 0) {
  ------------------
  |  Branch (802:11): [True: 2, False: 181]
  ------------------
  803|      2|        throw std::out_of_range("empty 'mandatory' values");
  804|      2|      }
  805|    181|      std::set<SvcParam::SvcParamKey> paramKeys;
  806|    181|      size_t stop = d_pos + len;
  807|   158k|      while (d_pos < stop) {
  ------------------
  |  Branch (807:14): [True: 157k, False: 181]
  ------------------
  808|   157k|        uint16_t keyval;
  809|   157k|        xfr16BitInt(keyval);
  810|   157k|        paramKeys.insert(static_cast<SvcParam::SvcParamKey>(keyval));
  811|   157k|      }
  812|    181|      kvs.insert(SvcParam(key, std::move(paramKeys)));
  813|    181|      break;
  814|    183|    }
  815|    141|    case SvcParam::alpn: [[fallthrough]];
  ------------------
  |  Branch (815:5): [True: 141, False: 1.03k]
  ------------------
  816|    176|    case SvcParam::docpath: {
  ------------------
  |  Branch (816:5): [True: 35, False: 1.13k]
  ------------------
  817|    176|      size_t stop = d_pos + len;
  818|    176|      std::vector<string> alpns;
  819|  14.8k|      while (d_pos < stop) {
  ------------------
  |  Branch (819:14): [True: 14.7k, False: 105]
  ------------------
  820|  14.7k|        string alpn;
  821|  14.7k|        uint8_t alpnLen = 0;
  822|  14.7k|        xfr8BitInt(alpnLen);
  823|  14.7k|        if (alpnLen == 0) {
  ------------------
  |  Branch (823:13): [True: 18, False: 14.6k]
  ------------------
  824|     18|          throw std::out_of_range("alpn length of 0");
  825|     18|        }
  826|  14.6k|        if (d_pos + alpnLen > stop) {
  ------------------
  |  Branch (826:13): [True: 53, False: 14.6k]
  ------------------
  827|     53|          throw std::out_of_range("alpn length is larger than rest of alpn SVC Param");
  828|     53|        }
  829|  14.6k|        xfrBlob(alpn, alpnLen);
  830|  14.6k|        alpns.push_back(std::move(alpn));
  831|  14.6k|      }
  832|    105|      kvs.insert(SvcParam(key, std::move(alpns)));
  833|    105|      break;
  834|    176|    }
  835|     27|    case SvcParam::no_default_alpn: [[fallthrough]];
  ------------------
  |  Branch (835:5): [True: 27, False: 1.14k]
  ------------------
  836|     45|    case SvcParam::ohttp: [[fallthrough]];
  ------------------
  |  Branch (836:5): [True: 18, False: 1.15k]
  ------------------
  837|     73|    case SvcParam::pvd: {
  ------------------
  |  Branch (837:5): [True: 28, False: 1.14k]
  ------------------
  838|     73|      if (len != 0) {
  ------------------
  |  Branch (838:11): [True: 15, False: 58]
  ------------------
  839|     15|        throw std::out_of_range("invalid length for " + SvcParam::keyToString(key));
  840|     15|      }
  841|     58|      kvs.insert(SvcParam(key));
  842|     58|      break;
  843|     73|    }
  844|     25|    case SvcParam::port: {
  ------------------
  |  Branch (844:5): [True: 25, False: 1.14k]
  ------------------
  845|     25|      if (len != 2) {
  ------------------
  |  Branch (845:11): [True: 13, False: 12]
  ------------------
  846|     13|        throw std::out_of_range("invalid length for port");
  847|     13|      }
  848|     12|      uint16_t port;
  849|     12|      xfr16BitInt(port);
  850|     12|      kvs.insert(SvcParam(key, port));
  851|     12|      break;
  852|     25|    }
  853|    107|    case SvcParam::ipv4hint:
  ------------------
  |  Branch (853:5): [True: 107, False: 1.06k]
  ------------------
  854|    146|    case SvcParam::ipv6hint: {
  ------------------
  |  Branch (854:5): [True: 39, False: 1.13k]
  ------------------
  855|    146|      size_t addrLen = (key == SvcParam::ipv4hint ? 4 : 16);
  ------------------
  |  Branch (855:25): [True: 107, False: 39]
  ------------------
  856|    146|      if (len % addrLen != 0) {
  ------------------
  |  Branch (856:11): [True: 2, False: 144]
  ------------------
  857|      2|        throw std::out_of_range("invalid length for " + SvcParam::keyToString(key));
  858|      2|      }
  859|    144|      vector<ComboAddress> addresses;
  860|    144|      auto stop = d_pos + len;
  861|  31.8k|      while (d_pos < stop)
  ------------------
  |  Branch (861:14): [True: 31.7k, False: 144]
  ------------------
  862|  31.7k|      {
  863|  31.7k|        ComboAddress addr;
  864|  31.7k|        xfrCAWithoutPort(key, addr);
  865|  31.7k|        addresses.push_back(addr);
  866|  31.7k|      }
  867|       |      // If there were no addresses, and the input comes from internal
  868|       |      // representation, we can reasonably assume this is the serialization
  869|       |      // of "auto".
  870|    144|      bool doAuto{d_internal && len == 0};
  ------------------
  |  Branch (870:19): [True: 0, False: 144]
  |  Branch (870:33): [True: 0, False: 0]
  ------------------
  871|    144|      auto param = SvcParam(key, std::move(addresses));
  872|    144|      param.setAutoHint(doAuto);
  873|    144|      kvs.insert(std::move(param));
  874|    144|      break;
  875|    146|    }
  876|     33|    case SvcParam::ech: {
  ------------------
  |  Branch (876:5): [True: 33, False: 1.14k]
  ------------------
  877|     33|      std::string blob;
  878|     33|      blob.reserve(len);
  879|     33|      xfrBlobNoSpaces(blob, len);
  880|     33|      kvs.insert(SvcParam(key, blob));
  881|     33|      break;
  882|    146|    }
  883|     85|    case SvcParam::tls_supported_groups: {
  ------------------
  |  Branch (883:5): [True: 85, False: 1.08k]
  ------------------
  884|     85|      if (len % 2 != 0) {
  ------------------
  |  Branch (884:11): [True: 1, False: 84]
  ------------------
  885|      1|        throw std::out_of_range("invalid length for " + SvcParam::keyToString(key));
  886|      1|      }
  887|     84|      vector<uint16_t> groups;
  888|     84|      groups.reserve(len / 2);
  889|     84|      auto stop = d_pos + len;
  890|  45.1k|      while (d_pos < stop)
  ------------------
  |  Branch (890:14): [True: 45.0k, False: 84]
  ------------------
  891|  45.0k|      {
  892|  45.0k|        uint16_t group = 0;
  893|  45.0k|        xfr16BitInt(group);
  894|  45.0k|        groups.push_back(group);
  895|  45.0k|      }
  896|     84|      auto param = SvcParam(key, std::move(groups));
  897|     84|      kvs.insert(std::move(param));
  898|     84|      break;
  899|     85|    }
  900|    410|    default: {
  ------------------
  |  Branch (900:5): [True: 410, False: 763]
  ------------------
  901|    410|      std::string blob;
  902|    410|      blob.reserve(len);
  903|    410|      xfrBlob(blob, len);
  904|    410|      kvs.insert(SvcParam(key, blob));
  905|    410|      break;
  906|     85|    }
  907|  1.17k|    }
  908|  1.17k|  }
  909|    927|}
_ZN12PacketReader10xfrHexBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb:
  913|    386|{
  914|    386|  xfrBlob(blob);
  915|    386|}

_ZN9DNSRecordC2Ev:
  376|  9.29k|    d_class(QClass::IN)
  377|  9.29k|  {}
_ZN15MOADNSExceptionC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   61|  1.62k|  MOADNSException(const string& str) : runtime_error(str)
   62|  1.62k|  {}
_ZN16DNSRecordContentD2Ev:
  266|  9.24k|  virtual ~DNSRecordContent() = default;
_ZN12PacketReaderC2ERKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEtbb:
   72|  4.16k|    : d_pos(initialPos), d_startrecordpos(initialPos), d_internal(internalRepresentation), d_standalone(standalone), d_content(content)
   73|  4.16k|  {
   74|  4.16k|    if (content.size() > std::numeric_limits<uint16_t>::max()) {
  ------------------
  |  Branch (74:9): [True: 0, False: 4.16k]
  ------------------
   75|      0|      throw std::out_of_range("packet too large");
   76|      0|    }
   77|       |
   78|  4.16k|    d_recordlen = static_cast<uint16_t>(content.size());
   79|  4.16k|    d_pointerBudget = static_cast<size_t>(d_recordlen) * s_MaxPointersPerByte;
   80|  4.16k|  }
_ZNK12PacketReader11getPositionEv:
  205|  26.2k|  {
  206|  26.2k|    return d_pos;
  207|  26.2k|  }
_ZN9DNSRecord10setContentEONSt3__110shared_ptrIK16DNSRecordContentEE:
  432|  7.67k|  {
  433|  7.67k|    d_content = std::move(content);
  434|  7.67k|  }
_ZNK12PacketReader24isWithinRecordBoundariesEmmb:
  227|   324k|  {
  228|   324k|    if (initialPosition > endPosition) {
  ------------------
  |  Branch (228:9): [True: 0, False: 324k]
  ------------------
  229|      0|      return false;
  230|      0|    }
  231|   324k|    if (canBeOutsideRecordContent && d_recordlen == 0) {
  ------------------
  |  Branch (231:9): [True: 16.6k, False: 308k]
  |  Branch (231:38): [True: 1.68k, False: 15.0k]
  ------------------
  232|       |      // we don't know the record's length, nothing to check
  233|  1.68k|      return true;
  234|  1.68k|    }
  235|   323k|    const size_t endOfRecordContent = d_startrecordpos + d_recordlen;
  236|   323k|    if (canBeOutsideRecordContent && initialPosition >= endOfRecordContent) {
  ------------------
  |  Branch (236:9): [True: 15.0k, False: 308k]
  |  Branch (236:38): [True: 3.84k, False: 11.1k]
  ------------------
  237|       |      // our initial position is after the last known record content,
  238|       |      // we are probably parsing the owner name of the next record,
  239|       |      // nothing to check
  240|  3.84k|      return true;
  241|  3.84k|    }
  242|       |    // are we still inside the record's content?
  243|   319k|    return initialPosition >= d_startrecordpos && initialPosition <= endOfRecordContent && endPosition <= endOfRecordContent;
  ------------------
  |  Branch (243:12): [True: 319k, False: 0]
  |  Branch (243:51): [True: 319k, False: 18]
  |  Branch (243:92): [True: 318k, False: 500]
  ------------------
  244|   323k|  }
_ZN12PacketReader11xfr16BitIntERt:
  131|   228k|  {
  132|   228k|    val=get16BitInt();
  133|   228k|  }
_ZN12PacketReader10xfr8BitIntERh:
  142|  68.2k|  {
  143|  68.2k|    val=get8BitInt();
  144|  68.2k|  }
_ZN12PacketReader16xfrCAWithoutPortEhR12ComboAddress:
  110|  31.7k|  void xfrCAWithoutPort(uint8_t version, ComboAddress &val) {
  111|  31.7k|    string blob;
  112|  31.7k|    if (version == 4) xfrBlob(blob, 4);
  ------------------
  |  Branch (112:9): [True: 31.3k, False: 361]
  ------------------
  113|    361|    else if (version == 6) xfrBlob(blob, 16);
  ------------------
  |  Branch (113:14): [True: 361, False: 0]
  ------------------
  114|      0|    else throw runtime_error("invalid IP protocol");
  115|  31.7k|    val = makeComboAddressFromRaw(version, blob);
  116|  31.7k|  }
_ZN20UnknownRecordContentC2ERK9DNSRecordR12PacketReader:
  530|  1.64k|    : d_dr(dr)
  531|  1.64k|  {
  532|  1.64k|    pr.copyRecord(d_record, dr.d_clen);
  533|  1.64k|  }
_ZN12PacketReader11xfr32BitIntERj:
   96|  1.58k|  {
   97|  1.58k|    val=get32BitInt();
   98|  1.58k|  }
_ZN12PacketReader5xfrIPERj:
  101|     74|  {
  102|     74|    xfr32BitInt(val);
  103|       |    val=htonl(val);
  104|     74|  }
_ZN12PacketReader6xfrIP6ERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  106|     54|  void xfrIP6(std::string &val) {
  107|     54|    xfrBlob(val, 16);
  108|     54|  }
_ZN12PacketReader7xfrTimeERj:
  125|    140|  {
  126|    140|    xfr32BitInt(val);
  127|    140|  }
_ZN12PacketReader7xfrTypeERt:
  136|     80|  {
  137|     80|    xfr16BitInt(val);
  138|     80|  }
_ZN12PacketReader7xfrNameER7DNSNameb:
  147|  3.39k|  {
  148|  3.39k|    name = getName();
  149|  3.39k|  }
_ZN12PacketReader7xfrTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEbb:
  152|  1.15k|  {
  153|  1.15k|    text=getText(multi, lenField);
  154|  1.15k|  }
_ZN12PacketReader15xfrUnquotedTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb:
  156|    515|  void xfrUnquotedText(string &text, bool lenField){
  157|    515|    text=getUnquotedText(lenField);
  158|    515|  }
_ZNK12PacketReader3eofEv:
  178|  6.25k|  {
  179|  6.25k|    const auto endOfRecordContent = d_startrecordpos + d_recordlen;
  180|  6.25k|    if (d_pos > endOfRecordContent) {
  ------------------
  |  Branch (180:9): [True: 74, False: 6.17k]
  ------------------
  181|     74|      throw std::out_of_range("Looking for EOF in PacketReader but we are already beyond the record content's end (" + std::to_string(d_pos) + " while the record content starts at " + std::to_string(d_startrecordpos) + " with a size of " + std::to_string(d_recordlen) + ")");
  182|     74|    }
  183|  6.17k|    return d_pos == endOfRecordContent;
  184|  6.25k|  }
_ZNK12PacketReader12getRemainingEv:
  188|    202|  [[nodiscard]] std::string getRemaining() const {
  189|    202|    return "Remaining data from PacketReader, current position " + std::to_string(d_pos) + " in packet of size " + std::to_string(d_content.size()) + ", end of record expected at " + std::to_string(d_startrecordpos + d_recordlen) + ": " + makeHexDump(std::string(d_content.begin() + d_pos, d_content.begin() + d_startrecordpos + d_recordlen));
  190|    202|  };
_ZN12PacketReader16consumeRemainingEv:
  199|    997|  {
  200|    997|    d_pos = (d_startrecordpos + d_recordlen);
  201|    997|  }
_ZN16DNSRecordContent13doRecordCheckERK9DNSRecord:
  303|  6.15k|  void doRecordCheck(const struct DNSRecord&){}
_ZN16DNSRecordContent6registEttPFNSt3__110shared_ptrIS_EERK9DNSRecordR12PacketReaderEPFS2_RKNS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEEPKc:
  309|    118|  {
  310|    118|    assert(!d_locked.load()); // NOLINT: it's the API
  ------------------
  |  Branch (310:5): [True: 118, False: 0]
  ------------------
  311|    118|    if(f)
  ------------------
  |  Branch (311:8): [True: 115, False: 3]
  ------------------
  312|    115|      getTypemap()[pair(cl,ty)]=f;
  313|    118|    if(z)
  ------------------
  |  Branch (313:8): [True: 115, False: 3]
  ------------------
  314|    115|      getZmakermap()[pair(cl,ty)]=z;
  315|       |
  316|    118|    getT2Namemap().emplace(pair(cl, ty), name);
  317|    118|    getN2Typemap().emplace(name, pair(cl, ty));
  318|    118|  }
_ZN16DNSRecordContent4lockEv:
  355|      1|  {
  356|      1|    d_locked.store(true);
  357|      1|  }
_ZN12MOADNSParserC2EbPKcjm:
  570|  4.16k|  MOADNSParser(bool query, const char *packet, unsigned int len, size_t pointerBudget = 0) : d_tsigPos(0)
  571|  4.16k|  {
  572|  4.16k|    init(query, std::string_view(packet, len), pointerBudget);
  573|  4.16k|  }

_ZN14ARecordContent13doRecordCheckERK9DNSRecord:
  141|     62|{
  142|     62|  if(dr.d_clen!=4)
  ------------------
  |  Branch (142:6): [True: 28, False: 34]
  ------------------
  143|     28|    throw MOADNSException("Wrong size for A record ("+std::to_string(dr.d_clen)+")");
  144|     62|}
_ZN19DNSKEYRecordContentC2Ev:
  463|     68|DNSKEYRecordContent::DNSKEYRecordContent() = default;
_ZN18EUI48RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  500|      1|{
  501|      1|  regist(1, QType::EUI48, &make, &make, "EUI48");
  502|      1|}
_ZN18EUI48RecordContent4makeERK9DNSRecordR12PacketReader:
  504|    100|{
  505|    100|    if(dr.d_clen!=6)
  ------------------
  |  Branch (505:8): [True: 24, False: 76]
  ------------------
  506|     24|      throw MOADNSException("Wrong size for EUI48 record");
  507|       |
  508|     76|    auto ret=std::make_shared<EUI48RecordContent>();
  509|     76|    pr.copyRecord((uint8_t*) &ret->d_eui48, 6);
  510|     76|    if (!pr.eof()) {
  ------------------
  |  Branch (510:9): [True: 0, False: 76]
  ------------------
  511|      0|      throw MOADNSException("When parsing EUI48 trailing data was not parsed: '" + pr.getRemaining() + "'");
  512|      0|    }
  513|     76|    return ret;
  514|     76|}
_ZN18EUI64RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  547|      1|{
  548|      1|  regist(1, QType::EUI64, &make, &make, "EUI64");
  549|      1|}
_ZN18EUI64RecordContent4makeERK9DNSRecordR12PacketReader:
  551|     57|{
  552|     57|    if(dr.d_clen!=8)
  ------------------
  |  Branch (552:8): [True: 24, False: 33]
  ------------------
  553|     24|      throw MOADNSException("Wrong size for EUI64 record");
  554|       |
  555|     33|    auto ret=std::make_shared<EUI64RecordContent>();
  556|     33|    pr.copyRecord((uint8_t*) &ret->d_eui64, 8);
  557|     33|    if (!pr.eof()) {
  ------------------
  |  Branch (557:9): [True: 0, False: 33]
  ------------------
  558|      0|      throw MOADNSException("When parsing EUI64 trailing data was not parsed: '" + pr.getRemaining() + "'");
  559|      0|    }
  560|     33|    return ret;
  561|     33|}
_ZN16APLRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  596|      1|{
  597|      1|  regist(1, QType::APL, &make, &make, "APL");
  598|      1|}
_ZN16APLRecordContent4makeERK9DNSRecordR12PacketReader:
  601|    202|std::shared_ptr<DNSRecordContent> APLRecordContent::make(const DNSRecord &dr, PacketReader& pr) {
  602|    202|  uint8_t temp;
  603|    202|  APLRDataElement ard;
  604|    202|  size_t processed = 0;
  605|       |
  606|    202|  auto ret=std::make_shared<APLRecordContent>();
  607|       |
  608|  20.6k|  while (processed<dr.d_clen) {
  ------------------
  |  Branch (608:10): [True: 20.5k, False: 119]
  ------------------
  609|  20.5k|    if (dr.d_clen - processed < 4) {
  ------------------
  |  Branch (609:9): [True: 14, False: 20.5k]
  ------------------
  610|     14|      throw MOADNSException("Malformed APL record, element header extends beyond record length");
  611|     14|    }
  612|  20.5k|    pr.xfr16BitInt(ard.d_family);
  613|  20.5k|    pr.xfr8BitInt(ard.d_prefix);
  614|  20.5k|    pr.xfr8BitInt(temp);
  615|  20.5k|    ard.d_n = (temp & 128) >> 7;
  616|  20.5k|    ard.d_afdlength = temp & 127;
  617|       |
  618|  20.5k|    if (ard.d_afdlength > dr.d_clen - processed - 4) {
  ------------------
  |  Branch (618:9): [True: 7, False: 20.5k]
  ------------------
  619|      7|      throw MOADNSException("Malformed APL record, address data extends beyond record length");
  620|      7|    }
  621|       |
  622|  20.5k|    if (ard.d_family == APL_FAMILY_IPV4) {
  ------------------
  |  | 1201|  20.5k|#define APL_FAMILY_IPV4 1
  ------------------
  |  Branch (622:9): [True: 11.6k, False: 8.85k]
  ------------------
  623|  11.6k|      if (ard.d_afdlength > 4) {
  ------------------
  |  Branch (623:11): [True: 4, False: 11.6k]
  ------------------
  624|      4|        throw MOADNSException("Invalid IP length for IPv4 APL");
  625|      4|      }
  626|  11.6k|      memset(ard.d_ip.d_ip4, 0, sizeof(ard.d_ip.d_ip4));
  627|  19.2k|      for (u_int i=0; i < ard.d_afdlength; i++)
  ------------------
  |  Branch (627:23): [True: 7.60k, False: 11.6k]
  ------------------
  628|  7.60k|        pr.xfr8BitInt(ard.d_ip.d_ip4[i]);
  629|  11.6k|    } else if (ard.d_family == APL_FAMILY_IPV6) {
  ------------------
  |  | 1202|  8.85k|#define APL_FAMILY_IPV6 2
  ------------------
  |  Branch (629:16): [True: 8.79k, False: 56]
  ------------------
  630|  8.79k|      if (ard.d_afdlength > 16) {
  ------------------
  |  Branch (630:11): [True: 2, False: 8.79k]
  ------------------
  631|      2|        throw MOADNSException("Invalid IP length for IPv6 APL");
  632|      2|      }
  633|  8.79k|      memset(ard.d_ip.d_ip6, 0, sizeof(ard.d_ip.d_ip6));
  634|  10.1k|      for (u_int i=0; i < ard.d_afdlength; i++)
  ------------------
  |  Branch (634:23): [True: 1.37k, False: 8.79k]
  ------------------
  635|  1.37k|        pr.xfr8BitInt(ard.d_ip.d_ip6[i]);
  636|  8.79k|    } else {
  637|     56|      throw MOADNSException("Unknown family for APL record");
  638|     56|    }
  639|       |
  640|  20.4k|    processed += 4 + ard.d_afdlength;
  641|       |
  642|  20.4k|    ret->aplrdata.push_back(ard);
  643|  20.4k|  }
  644|    119|  if (!pr.eof()) {
  ------------------
  |  Branch (644:7): [True: 0, False: 119]
  ------------------
  645|      0|    throw MOADNSException("When parsing APL trailing data was not parsed: '" + pr.getRemaining() + "'");
  646|      0|  }
  647|       |
  648|    119|  return ret;
  649|    119|}
_Z14reportAllTypesv:
 1060|      1|{
 1061|      1|  ReportIsOnlyCallableByReportAllTypes guard;
 1062|      1|  reportBasicTypes(guard);
 1063|      1|  reportOtherTypes(guard);
 1064|      1|  DNSRecordContent::lock();
 1065|      1|}
dnsrecords.cc:_ZL16reportBasicTypesRK36ReportIsOnlyCallableByReportAllTypes:
  977|      1|{
  978|      1|  ARecordContent::report(guard);
  979|      1|  AAAARecordContent::report(guard);
  980|      1|  NSRecordContent::report(guard);
  981|      1|  CNAMERecordContent::report(guard);
  982|      1|  MXRecordContent::report(guard);
  983|      1|  SOARecordContent::report(guard);
  984|      1|  SRVRecordContent::report(guard);
  985|      1|  PTRRecordContent::report(guard);
  986|      1|  DNSRecordContent::regist(QClass::CHAOS, QType::TXT, &TXTRecordContent::make, &TXTRecordContent::make, "TXT");
  987|      1|  TXTRecordContent::report(guard);
  988|       |#ifdef HAVE_LUA_RECORDS
  989|       |  LUARecordContent::report(guard);
  990|       |#endif
  991|      1|  DNSRecordContent::regist(QClass::IN, QType::ANY, nullptr, nullptr, "ANY");
  992|      1|  DNSRecordContent::regist(QClass::IN, QType::AXFR, nullptr, nullptr, "AXFR");
  993|      1|  DNSRecordContent::regist(QClass::IN, QType::IXFR, nullptr, nullptr, "IXFR");
  994|      1|}
dnsrecords.cc:_ZL16reportOtherTypesRK36ReportIsOnlyCallableByReportAllTypes:
  997|      1|{
  998|      1|   MBRecordContent::report(guard);
  999|      1|   MGRecordContent::report(guard);
 1000|      1|   MRRecordContent::report(guard);
 1001|      1|   AFSDBRecordContent::report(guard);
 1002|      1|   DNAMERecordContent::report(guard);
 1003|      1|#if !defined(RECURSOR)
 1004|      1|   ALIASRecordContent::report(guard);
 1005|      1|#endif
 1006|      1|   SPFRecordContent::report(guard);
 1007|      1|   NAPTRRecordContent::report(guard);
 1008|      1|   KXRecordContent::report(guard);
 1009|      1|   LOCRecordContent::report(guard);
 1010|      1|   ENTRecordContent::report(guard);
 1011|      1|   HINFORecordContent::report(guard);
 1012|      1|   RPRecordContent::report(guard);
 1013|      1|   KEYRecordContent::report(guard);
 1014|      1|   DNSKEYRecordContent::report(guard);
 1015|      1|   DHCIDRecordContent::report(guard);
 1016|      1|   CDNSKEYRecordContent::report(guard);
 1017|      1|   RKEYRecordContent::report(guard);
 1018|      1|   RRSIGRecordContent::report(guard);
 1019|      1|   DSRecordContent::report(guard);
 1020|      1|   CDSRecordContent::report(guard);
 1021|      1|   SSHFPRecordContent::report(guard);
 1022|      1|   CERTRecordContent::report(guard);
 1023|      1|   NSECRecordContent::report(guard);
 1024|      1|   NSEC3RecordContent::report(guard);
 1025|      1|   NSEC3PARAMRecordContent::report(guard);
 1026|      1|   TLSARecordContent::report(guard);
 1027|      1|   SMIMEARecordContent::report(guard);
 1028|      1|   OPENPGPKEYRecordContent::report(guard);
 1029|      1|   SVCBRecordContent::report(guard);
 1030|      1|   HTTPSRecordContent::report(guard);
 1031|      1|   HHITRecordContent::report(guard);
 1032|      1|   BRIDRecordContent::report(guard);
 1033|      1|   DLVRecordContent::report(guard);
 1034|      1|   DNSRecordContent::regist(QClass::ANY, QType::TSIG, &TSIGRecordContent::make, &TSIGRecordContent::make, "TSIG");
 1035|      1|   DNSRecordContent::regist(QClass::ANY, QType::TKEY, &TKEYRecordContent::make, &TKEYRecordContent::make, "TKEY");
 1036|       |   //TSIGRecordContent::report(guard);
 1037|      1|   OPTRecordContent::report(guard);
 1038|      1|   EUI48RecordContent::report(guard);
 1039|      1|   EUI64RecordContent::report(guard);
 1040|      1|   MINFORecordContent::report(guard);
 1041|      1|   URIRecordContent::report(guard);
 1042|      1|   CAARecordContent::report(guard);
 1043|      1|   RESINFORecordContent::report(guard);
 1044|      1|   APLRecordContent::report(guard);
 1045|      1|   IPSECKEYRecordContent::report(guard);
 1046|      1|   CSYNCRecordContent::report(guard);
 1047|      1|   NIDRecordContent::report(guard);
 1048|      1|   L32RecordContent::report(guard);
 1049|      1|   L64RecordContent::report(guard);
 1050|      1|   LPRecordContent::report(guard);
 1051|      1|   WALLETRecordContent::report(guard);
 1052|      1|   ZONEMDRecordContent::report(guard);
 1053|      1|}

_ZN14ARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     62|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     62|{                                                                                                  \
 1293|     62|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     62|}                                                                                                  \
_ZN14ARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     62|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     62|{                                                                                                  \
 1298|     62|  doRecordCheck(dr);                                                                               \
 1299|     62|  xfrPacket(pr);                                                                                   \
 1300|     62|}                                                                                                  \
_ZN14ARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17AAAARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     42|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     42|{                                                                                                  \
 1293|     42|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     42|}                                                                                                  \
_ZN17AAAARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     42|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     42|{                                                                                                  \
 1298|     42|  doRecordCheck(dr);                                                                               \
 1299|     42|  xfrPacket(pr);                                                                                   \
 1300|     42|}                                                                                                  \
_ZN17AAAARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15NSRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    124|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    124|{                                                                                                  \
 1293|    124|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    124|}                                                                                                  \
_ZN15NSRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    124|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    124|{                                                                                                  \
 1298|    124|  doRecordCheck(dr);                                                                               \
 1299|    124|  xfrPacket(pr);                                                                                   \
 1300|    124|}                                                                                                  \
_ZN15NSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16PTRRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     60|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     60|{                                                                                                  \
 1293|     60|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     60|}                                                                                                  \
_ZN16PTRRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     60|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     60|{                                                                                                  \
 1298|     60|  doRecordCheck(dr);                                                                               \
 1299|     60|  xfrPacket(pr);                                                                                   \
 1300|     60|}                                                                                                  \
_ZN16PTRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18CNAMERecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    100|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    100|{                                                                                                  \
 1293|    100|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    100|}                                                                                                  \
_ZN18CNAMERecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    100|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    100|{                                                                                                  \
 1298|    100|  doRecordCheck(dr);                                                                               \
 1299|    100|  xfrPacket(pr);                                                                                   \
 1300|    100|}                                                                                                  \
_ZN18CNAMERecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18ALIASRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     84|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     84|{                                                                                                  \
 1293|     84|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     84|}                                                                                                  \
_ZN18ALIASRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     84|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     84|{                                                                                                  \
 1298|     84|  doRecordCheck(dr);                                                                               \
 1299|     84|  xfrPacket(pr);                                                                                   \
 1300|     84|}                                                                                                  \
_ZN18ALIASRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18DNAMERecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     62|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     62|{                                                                                                  \
 1293|     62|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     62|}                                                                                                  \
_ZN18DNAMERecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     62|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     62|{                                                                                                  \
 1298|     62|  doRecordCheck(dr);                                                                               \
 1299|     62|  xfrPacket(pr);                                                                                   \
 1300|     62|}                                                                                                  \
_ZN18DNAMERecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15MBRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     71|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     71|{                                                                                                  \
 1293|     71|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     71|}                                                                                                  \
_ZN15MBRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     71|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     71|{                                                                                                  \
 1298|     71|  doRecordCheck(dr);                                                                               \
 1299|     71|  xfrPacket(pr);                                                                                   \
 1300|     71|}                                                                                                  \
_ZN15MBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15MGRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     67|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     67|{                                                                                                  \
 1293|     67|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     67|}                                                                                                  \
_ZN15MGRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     67|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     67|{                                                                                                  \
 1298|     67|  doRecordCheck(dr);                                                                               \
 1299|     67|  xfrPacket(pr);                                                                                   \
 1300|     67|}                                                                                                  \
_ZN15MGRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15MRRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     81|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     81|{                                                                                                  \
 1293|     81|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     81|}                                                                                                  \
_ZN15MRRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     81|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     81|{                                                                                                  \
 1298|     81|  doRecordCheck(dr);                                                                               \
 1299|     81|  xfrPacket(pr);                                                                                   \
 1300|     81|}                                                                                                  \
_ZN15MRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18MINFORecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    128|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    128|{                                                                                                  \
 1293|    128|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    128|}                                                                                                  \
_ZN18MINFORecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    128|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    128|{                                                                                                  \
 1298|    128|  doRecordCheck(dr);                                                                               \
 1299|    128|  xfrPacket(pr);                                                                                   \
 1300|    128|}                                                                                                  \
_ZN18MINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16TXTRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     88|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     88|{                                                                                                  \
 1293|     88|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     88|}                                                                                                  \
_ZN16TXTRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     88|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     88|{                                                                                                  \
 1298|     88|  doRecordCheck(dr);                                                                               \
 1299|     88|  xfrPacket(pr);                                                                                   \
 1300|     88|}                                                                                                  \
_ZN16TXTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16ENTRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    997|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    997|{                                                                                                  \
 1293|    997|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    997|}                                                                                                  \
_ZN16ENTRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    997|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    997|{                                                                                                  \
 1298|    997|  doRecordCheck(dr);                                                                               \
 1299|    997|  xfrPacket(pr);                                                                                   \
 1300|    997|}                                                                                                  \
_ZN16ENTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16SPFRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     51|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     51|{                                                                                                  \
 1293|     51|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     51|}                                                                                                  \
_ZN16SPFRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     51|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     51|{                                                                                                  \
 1298|     51|  doRecordCheck(dr);                                                                               \
 1299|     51|  xfrPacket(pr);                                                                                   \
 1300|     51|}                                                                                                  \
_ZN16SPFRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18HINFORecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     73|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     73|{                                                                                                  \
 1293|     73|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     73|}                                                                                                  \
_ZN18HINFORecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     73|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     73|{                                                                                                  \
 1298|     73|  doRecordCheck(dr);                                                                               \
 1299|     73|  xfrPacket(pr);                                                                                   \
 1300|     73|}                                                                                                  \
_ZN18HINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15RPRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     83|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     83|{                                                                                                  \
 1293|     83|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     83|}                                                                                                  \
_ZN15RPRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     83|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     83|{                                                                                                  \
 1298|     83|  doRecordCheck(dr);                                                                               \
 1299|     83|  xfrPacket(pr);                                                                                   \
 1300|     83|}                                                                                                  \
_ZN15RPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16OPTRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    592|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    592|{                                                                                                  \
 1293|    592|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    592|}                                                                                                  \
_ZN16OPTRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    592|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    592|{                                                                                                  \
 1298|    592|  doRecordCheck(dr);                                                                               \
 1299|    592|  xfrPacket(pr);                                                                                   \
 1300|    592|}                                                                                                  \
_ZN16OPTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN19WALLETRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     72|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     72|{                                                                                                  \
 1293|     72|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     72|}                                                                                                  \
_ZN19WALLETRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     72|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     72|{                                                                                                  \
 1298|     72|  doRecordCheck(dr);                                                                               \
 1299|     72|  xfrPacket(pr);                                                                                   \
 1300|     72|}                                                                                                  \
_ZN19WALLETRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15MXRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     47|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     47|{                                                                                                  \
 1293|     47|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     47|}                                                                                                  \
_ZN15MXRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     47|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     47|{                                                                                                  \
 1298|     47|  doRecordCheck(dr);                                                                               \
 1299|     47|  xfrPacket(pr);                                                                                   \
 1300|     47|}                                                                                                  \
_ZN15MXRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15KXRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     50|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     50|{                                                                                                  \
 1293|     50|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     50|}                                                                                                  \
_ZN15KXRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     50|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     50|{                                                                                                  \
 1298|     50|  doRecordCheck(dr);                                                                               \
 1299|     50|  xfrPacket(pr);                                                                                   \
 1300|     50|}                                                                                                  \
_ZN15KXRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN21IPSECKEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    124|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    124|{                                                                                                  \
 1293|    124|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    124|}                                                                                                  \
_ZN21IPSECKEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    124|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    124|{                                                                                                  \
 1298|    124|  doRecordCheck(dr);                                                                               \
 1299|    124|  xfrPacket(pr);                                                                                   \
 1300|    124|}                                                                                                  \
_ZN21IPSECKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18DHCIDRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     62|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     62|{                                                                                                  \
 1293|     62|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     62|}                                                                                                  \
_ZN18DHCIDRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     62|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     62|{                                                                                                  \
 1298|     62|  doRecordCheck(dr);                                                                               \
 1299|     62|  xfrPacket(pr);                                                                                   \
 1300|     62|}                                                                                                  \
_ZN18DHCIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18AFSDBRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     49|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     49|{                                                                                                  \
 1293|     49|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     49|}                                                                                                  \
_ZN18AFSDBRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     49|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     49|{                                                                                                  \
 1298|     49|  doRecordCheck(dr);                                                                               \
 1299|     49|  xfrPacket(pr);                                                                                   \
 1300|     49|}                                                                                                  \
_ZN18AFSDBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18NAPTRRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     72|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     72|{                                                                                                  \
 1293|     72|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     72|}                                                                                                  \
_ZN18NAPTRRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     72|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     72|{                                                                                                  \
 1298|     72|  doRecordCheck(dr);                                                                               \
 1299|     72|  xfrPacket(pr);                                                                                   \
 1300|     72|}                                                                                                  \
_ZN18NAPTRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16SRVRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     39|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     39|{                                                                                                  \
 1293|     39|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     39|}                                                                                                  \
_ZN16SRVRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     39|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     39|{                                                                                                  \
 1298|     39|  doRecordCheck(dr);                                                                               \
 1299|     39|  xfrPacket(pr);                                                                                   \
 1300|     39|}                                                                                                  \
_ZN16SRVRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16SOARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    212|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    212|{                                                                                                  \
 1293|    212|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    212|}                                                                                                  \
_ZN16SOARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    212|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    212|{                                                                                                  \
 1298|    212|  doRecordCheck(dr);                                                                               \
 1299|    212|  xfrPacket(pr);                                                                                   \
 1300|    212|}                                                                                                  \
_ZN16SOARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16KEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     62|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     62|{                                                                                                  \
 1293|     62|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     62|}                                                                                                  \
_ZN16KEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     62|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     62|{                                                                                                  \
 1298|     62|  doRecordCheck(dr);                                                                               \
 1299|     62|  xfrPacket(pr);                                                                                   \
 1300|     62|}                                                                                                  \
_ZN16KEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN19ZONEMDRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     75|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     75|{                                                                                                  \
 1293|     75|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     75|}                                                                                                  \
_ZN19ZONEMDRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     75|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     75|{                                                                                                  \
 1298|     75|  doRecordCheck(dr);                                                                               \
 1299|     75|  xfrPacket(pr);                                                                                   \
 1300|     75|}                                                                                                  \
_ZN19ZONEMDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17CERTRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     60|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     60|{                                                                                                  \
 1293|     60|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     60|}                                                                                                  \
_ZN17CERTRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     60|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     60|{                                                                                                  \
 1298|     60|  doRecordCheck(dr);                                                                               \
 1299|     60|  xfrPacket(pr);                                                                                   \
 1300|     60|}                                                                                                  \
_ZN17CERTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17TLSARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     44|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     44|{                                                                                                  \
 1293|     44|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     44|}                                                                                                  \
_ZN17TLSARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     44|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     44|{                                                                                                  \
 1298|     44|  doRecordCheck(dr);                                                                               \
 1299|     44|  xfrPacket(pr);                                                                                   \
 1300|     44|}                                                                                                  \
_ZN17TLSARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN23OPENPGPKEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     40|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     40|{                                                                                                  \
 1293|     40|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     40|}                                                                                                  \
_ZN23OPENPGPKEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     40|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     40|{                                                                                                  \
 1298|     40|  doRecordCheck(dr);                                                                               \
 1299|     40|  xfrPacket(pr);                                                                                   \
 1300|     40|}                                                                                                  \
_ZN23OPENPGPKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17SVCBRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    584|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    584|{                                                                                                  \
 1293|    584|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    584|}                                                                                                  \
_ZN17SVCBRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    584|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    584|{                                                                                                  \
 1298|    584|  doRecordCheck(dr);                                                                               \
 1299|    584|  xfrPacket(pr);                                                                                   \
 1300|    584|}                                                                                                  \
_ZN17SVCBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18HTTPSRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    406|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    406|{                                                                                                  \
 1293|    406|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    406|}                                                                                                  \
_ZN18HTTPSRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    406|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    406|{                                                                                                  \
 1298|    406|  doRecordCheck(dr);                                                                               \
 1299|    406|  xfrPacket(pr);                                                                                   \
 1300|    406|}                                                                                                  \
_ZN18HTTPSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17HHITRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     25|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     25|{                                                                                                  \
 1293|     25|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     25|}                                                                                                  \
_ZN17HHITRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     25|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     25|{                                                                                                  \
 1298|     25|  doRecordCheck(dr);                                                                               \
 1299|     25|  xfrPacket(pr);                                                                                   \
 1300|     25|}                                                                                                  \
_ZN17HHITRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17BRIDRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     43|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     43|{                                                                                                  \
 1293|     43|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     43|}                                                                                                  \
_ZN17BRIDRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     43|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     43|{                                                                                                  \
 1298|     43|  doRecordCheck(dr);                                                                               \
 1299|     43|  xfrPacket(pr);                                                                                   \
 1300|     43|}                                                                                                  \
_ZN17BRIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN19SMIMEARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     47|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     47|{                                                                                                  \
 1293|     47|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     47|}                                                                                                  \
_ZN19SMIMEARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     47|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     47|{                                                                                                  \
 1298|     47|  doRecordCheck(dr);                                                                               \
 1299|     47|  xfrPacket(pr);                                                                                   \
 1300|     47|}                                                                                                  \
_ZN19SMIMEARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15DSRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     47|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     47|{                                                                                                  \
 1293|     47|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     47|}                                                                                                  \
_ZN15DSRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     47|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     47|{                                                                                                  \
 1298|     47|  doRecordCheck(dr);                                                                               \
 1299|     47|  xfrPacket(pr);                                                                                   \
 1300|     47|}                                                                                                  \
_ZN15DSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16CDSRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     76|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     76|{                                                                                                  \
 1293|     76|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     76|}                                                                                                  \
_ZN16CDSRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     76|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     76|{                                                                                                  \
 1298|     76|  doRecordCheck(dr);                                                                               \
 1299|     76|  xfrPacket(pr);                                                                                   \
 1300|     76|}                                                                                                  \
_ZN16CDSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16DLVRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     62|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     62|{                                                                                                  \
 1293|     62|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     62|}                                                                                                  \
_ZN16DLVRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     62|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     62|{                                                                                                  \
 1298|     62|  doRecordCheck(dr);                                                                               \
 1299|     62|  xfrPacket(pr);                                                                                   \
 1300|     62|}                                                                                                  \
_ZN16DLVRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18SSHFPRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     54|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     54|{                                                                                                  \
 1293|     54|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     54|}                                                                                                  \
_ZN18SSHFPRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     54|{                                                                                                  \
 1298|     54|  doRecordCheck(dr);                                                                               \
 1299|     54|  xfrPacket(pr);                                                                                   \
 1300|     54|}                                                                                                  \
_ZN18SSHFPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN18RRSIGRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     80|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     80|{                                                                                                  \
 1293|     80|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     80|}                                                                                                  \
_ZN18RRSIGRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     80|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     80|{                                                                                                  \
 1298|     80|  doRecordCheck(dr);                                                                               \
 1299|     80|  xfrPacket(pr);                                                                                   \
 1300|     80|}                                                                                                  \
_ZN18RRSIGRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN19DNSKEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     56|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     56|{                                                                                                  \
 1293|     56|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     56|}                                                                                                  \
_ZN19DNSKEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     56|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     56|{                                                                                                  \
 1298|     56|  doRecordCheck(dr);                                                                               \
 1299|     56|  xfrPacket(pr);                                                                                   \
 1300|     56|}                                                                                                  \
_ZN19DNSKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN20CDNSKEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     40|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     40|{                                                                                                  \
 1293|     40|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     40|}                                                                                                  \
_ZN20CDNSKEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     40|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     40|{                                                                                                  \
 1298|     40|  doRecordCheck(dr);                                                                               \
 1299|     40|  xfrPacket(pr);                                                                                   \
 1300|     40|}                                                                                                  \
_ZN20CDNSKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN17RKEYRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     35|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     35|{                                                                                                  \
 1293|     35|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     35|}                                                                                                  \
_ZN17RKEYRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     35|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     35|{                                                                                                  \
 1298|     35|  doRecordCheck(dr);                                                                               \
 1299|     35|  xfrPacket(pr);                                                                                   \
 1300|     35|}                                                                                                  \
_ZN17RKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16NIDRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     54|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     54|{                                                                                                  \
 1293|     54|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     54|}                                                                                                  \
_ZN16NIDRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     54|{                                                                                                  \
 1298|     54|  doRecordCheck(dr);                                                                               \
 1299|     54|  xfrPacket(pr);                                                                                   \
 1300|     54|}                                                                                                  \
_ZN16NIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16L32RecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     34|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     34|{                                                                                                  \
 1293|     34|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     34|}                                                                                                  \
_ZN16L32RecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     34|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     34|{                                                                                                  \
 1298|     34|  doRecordCheck(dr);                                                                               \
 1299|     34|  xfrPacket(pr);                                                                                   \
 1300|     34|}                                                                                                  \
_ZN16L32RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16L64RecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     57|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     57|{                                                                                                  \
 1293|     57|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     57|}                                                                                                  \
_ZN16L64RecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     57|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     57|{                                                                                                  \
 1298|     57|  doRecordCheck(dr);                                                                               \
 1299|     57|  xfrPacket(pr);                                                                                   \
 1300|     57|}                                                                                                  \
_ZN16L64RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN15LPRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     54|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     54|{                                                                                                  \
 1293|     54|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     54|}                                                                                                  \
_ZN15LPRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     54|{                                                                                                  \
 1298|     54|  doRecordCheck(dr);                                                                               \
 1299|     54|  xfrPacket(pr);                                                                                   \
 1300|     54|}                                                                                                  \
_ZN15LPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16URIRecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    102|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    102|{                                                                                                  \
 1293|    102|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    102|}                                                                                                  \
_ZN16URIRecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    102|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    102|{                                                                                                  \
 1298|    102|  doRecordCheck(dr);                                                                               \
 1299|    102|  xfrPacket(pr);                                                                                   \
 1300|    102|}                                                                                                  \
_ZN16URIRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN16CAARecordContent4makeERK9DNSRecordR12PacketReader:
 1291|    531|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|    531|{                                                                                                  \
 1293|    531|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|    531|}                                                                                                  \
_ZN16CAARecordContentC2ERK9DNSRecordR12PacketReader:
 1296|    531|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|    531|{                                                                                                  \
 1298|    531|  doRecordCheck(dr);                                                                               \
 1299|    531|  xfrPacket(pr);                                                                                   \
 1300|    531|}                                                                                                  \
_ZN16CAARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN20RESINFORecordContent4makeERK9DNSRecordR12PacketReader:
 1291|     60|std::shared_ptr<RNAME##RecordContent::DNSRecordContent> RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \
 1292|     60|{                                                                                                  \
 1293|     60|  return std::make_shared<RNAME##RecordContent>(dr, pr);                                           \
 1294|     60|}                                                                                                  \
_ZN20RESINFORecordContentC2ERK9DNSRecordR12PacketReader:
 1296|     60|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr)                  \
 1297|     60|{                                                                                                  \
 1298|     60|  doRecordCheck(dr);                                                                               \
 1299|     60|  xfrPacket(pr);                                                                                   \
 1300|     60|}                                                                                                  \
_ZN20RESINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
 1312|      1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */)        \
 1313|      1|{                                                                                                  \
 1314|      1|  regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);       \
 1315|      1|  regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME);     \
 1316|      1|}                                                                                                  \
_ZN14ARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     34|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     34|{                                                                       \
 1343|     34|  CONV;                                                                 \
 1344|     34|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 34]
  ------------------
 1345|     34|}                                                                       \
_ZN17AAAARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     42|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     42|{                                                                       \
 1343|     42|  CONV;                                                                 \
 1344|     42|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 4, False: 38]
  ------------------
 1345|     42|}                                                                       \
_ZN15NSRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    124|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    124|{                                                                       \
 1343|    124|  CONV;                                                                 \
 1344|    124|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 34, False: 90]
  ------------------
 1345|    124|}                                                                       \
_ZN16PTRRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     60|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     60|{                                                                       \
 1343|     60|  CONV;                                                                 \
 1344|     60|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 12, False: 48]
  ------------------
 1345|     60|}                                                                       \
_ZN18CNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    100|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    100|{                                                                       \
 1343|    100|  CONV;                                                                 \
 1344|    100|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 17, False: 83]
  ------------------
 1345|    100|}                                                                       \
_ZN18ALIASRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     84|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     84|{                                                                       \
 1343|     84|  CONV;                                                                 \
 1344|     84|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 5, False: 79]
  ------------------
 1345|     84|}                                                                       \
_ZN18DNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     62|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     62|{                                                                       \
 1343|     62|  CONV;                                                                 \
 1344|     62|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 11, False: 51]
  ------------------
 1345|     62|}                                                                       \
_ZN15MBRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     71|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     71|{                                                                       \
 1343|     71|  CONV;                                                                 \
 1344|     71|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 6, False: 65]
  ------------------
 1345|     71|}                                                                       \
_ZN15MGRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     67|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     67|{                                                                       \
 1343|     67|  CONV;                                                                 \
 1344|     67|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 9, False: 58]
  ------------------
 1345|     67|}                                                                       \
_ZN15MRRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     81|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     81|{                                                                       \
 1343|     81|  CONV;                                                                 \
 1344|     81|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 6, False: 75]
  ------------------
 1345|     81|}                                                                       \
_ZN18MINFORecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    128|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    128|{                                                                       \
 1343|    128|  CONV;                                                                 \
 1344|    128|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 5, False: 123]
  ------------------
 1345|    128|}                                                                       \
_ZN16TXTRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     88|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     88|{                                                                       \
 1343|     88|  CONV;                                                                 \
 1344|     88|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 88]
  ------------------
 1345|     88|}                                                                       \
_ZN16ENTRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    997|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    997|{                                                                       \
 1343|    997|  CONV;                                                                 \
 1344|    997|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 997]
  ------------------
 1345|    997|}                                                                       \
_ZN16SPFRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     51|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     51|{                                                                       \
 1343|     51|  CONV;                                                                 \
 1344|     51|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 51]
  ------------------
 1345|     51|}                                                                       \
_ZN18HINFORecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     73|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     73|{                                                                       \
 1343|     73|  CONV;                                                                 \
 1344|     73|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 6, False: 67]
  ------------------
 1345|     73|}                                                                       \
_ZN15RPRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     83|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     83|{                                                                       \
 1343|     83|  CONV;                                                                 \
 1344|     83|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 2, False: 81]
  ------------------
 1345|     83|}                                                                       \
_ZN16OPTRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    592|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    592|{                                                                       \
 1343|    592|  CONV;                                                                 \
 1344|    592|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 592]
  ------------------
 1345|    592|}                                                                       \
_ZN19WALLETRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     72|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     72|{                                                                       \
 1343|     72|  CONV;                                                                 \
 1344|     72|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 72]
  ------------------
 1345|     72|}                                                                       \
_ZN15MXRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     47|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     47|{                                                                       \
 1343|     47|  CONV;                                                                 \
 1344|     47|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 3, False: 44]
  ------------------
 1345|     47|}                                                                       \
_ZN15KXRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     50|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     50|{                                                                       \
 1343|     50|  CONV;                                                                 \
 1344|     50|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 1, False: 49]
  ------------------
 1345|     50|}                                                                       \
_ZN21IPSECKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    124|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    124|{                                                                       \
 1343|    130|  CONV;                                                                 \
  ------------------
  |  Branch (1343:3): [True: 3, False: 121]
  |  Branch (1343:3): [True: 38, False: 86]
  |  Branch (1343:3): [True: 12, False: 112]
  |  Branch (1343:3): [True: 11, False: 113]
  |  Branch (1343:3): [True: 54, False: 70]
  |  Branch (1343:3): [True: 2, False: 99]
  |  Branch (1343:3): [True: 29, False: 72]
  |  Branch (1343:3): [True: 35, False: 66]
  |  Branch (1343:3): [True: 35, False: 66]
  ------------------
 1344|     98|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 4, False: 94]
  ------------------
 1345|     98|}                                                                       \
_ZN18DHCIDRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     62|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     62|{                                                                       \
 1343|     62|  CONV;                                                                 \
 1344|     62|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 62]
  ------------------
 1345|     62|}                                                                       \
_ZN18AFSDBRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     49|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     49|{                                                                       \
 1343|     49|  CONV;                                                                 \
 1344|     49|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 1, False: 48]
  ------------------
 1345|     49|}                                                                       \
_ZN18NAPTRRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     72|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     72|{                                                                       \
 1343|     72|  CONV;                                                                 \
 1344|     72|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 4, False: 68]
  ------------------
 1345|     72|}                                                                       \
_ZN16SRVRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     39|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     39|{                                                                       \
 1343|     39|  CONV;                                                                 \
 1344|     39|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 2, False: 37]
  ------------------
 1345|     39|}                                                                       \
_ZN16SOARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    212|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    212|{                                                                       \
 1343|    212|  CONV;                                                                 \
 1344|    212|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 26, False: 186]
  ------------------
 1345|    212|}                                                                       \
_ZN16KEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     62|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     62|{                                                                       \
 1343|     62|  CONV;                                                                 \
 1344|     62|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 62]
  ------------------
 1345|     62|}                                                                       \
_ZN19ZONEMDRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     75|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     75|{                                                                       \
 1343|     75|  CONV;                                                                 \
 1344|     75|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 75]
  ------------------
 1345|     75|}                                                                       \
_ZN17CERTRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     60|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     60|{                                                                       \
 1343|     61|  CONV;                                                                 \
  ------------------
  |  Branch (1343:3): [True: 1, False: 59]
  ------------------
 1344|     59|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 59]
  ------------------
 1345|     59|}                                                                       \
_ZN17TLSARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     44|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     44|{                                                                       \
 1343|     44|  CONV;                                                                 \
 1344|     44|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 44]
  ------------------
 1345|     44|}                                                                       \
_ZN23OPENPGPKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     40|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     40|{                                                                       \
 1343|     40|  CONV;                                                                 \
 1344|     40|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 40]
  ------------------
 1345|     40|}                                                                       \
_ZN17SVCBRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    584|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    584|{                                                                       \
 1343|  1.13k|  CONV;                                                                 \
  ------------------
  |  Branch (1343:3): [True: 550, False: 34]
  ------------------
 1344|    584|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 2, False: 582]
  ------------------
 1345|    584|}                                                                       \
_ZN18HTTPSRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    406|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    406|{                                                                       \
 1343|    783|  CONV;                                                                 \
  ------------------
  |  Branch (1343:3): [True: 377, False: 29]
  ------------------
 1344|    406|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 1, False: 405]
  ------------------
 1345|    406|}                                                                       \
_ZN17HHITRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     25|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     25|{                                                                       \
 1343|     25|  CONV;                                                                 \
 1344|     25|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 25]
  ------------------
 1345|     25|}                                                                       \
_ZN17BRIDRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     43|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     43|{                                                                       \
 1343|     43|  CONV;                                                                 \
 1344|     43|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 43]
  ------------------
 1345|     43|}                                                                       \
_ZN19SMIMEARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     47|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     47|{                                                                       \
 1343|     47|  CONV;                                                                 \
 1344|     47|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 47]
  ------------------
 1345|     47|}                                                                       \
_ZN15DSRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     47|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     47|{                                                                       \
 1343|     47|  CONV;                                                                 \
 1344|     47|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 47]
  ------------------
 1345|     47|}                                                                       \
_ZN16CDSRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     76|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     76|{                                                                       \
 1343|     76|  CONV;                                                                 \
 1344|     76|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 76]
  ------------------
 1345|     76|}                                                                       \
_ZN16DLVRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     62|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     62|{                                                                       \
 1343|     62|  CONV;                                                                 \
 1344|     62|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 62]
  ------------------
 1345|     62|}                                                                       \
_ZN18SSHFPRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     54|{                                                                       \
 1343|     54|  CONV;                                                                 \
 1344|     54|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 54]
  ------------------
 1345|     54|}                                                                       \
_ZN18RRSIGRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     80|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     80|{                                                                       \
 1343|     80|  CONV;                                                                 \
 1344|     80|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 80]
  ------------------
 1345|     80|}                                                                       \
_ZN19DNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     56|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     56|{                                                                       \
 1343|     56|  CONV;                                                                 \
 1344|     56|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 56]
  ------------------
 1345|     56|}                                                                       \
_ZN20CDNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     40|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     40|{                                                                       \
 1343|     40|  CONV;                                                                 \
 1344|     40|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 40]
  ------------------
 1345|     40|}                                                                       \
_ZN17RKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     35|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     35|{                                                                       \
 1343|     35|  CONV;                                                                 \
 1344|     35|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 35]
  ------------------
 1345|     35|}                                                                       \
_ZN16NIDRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     54|{                                                                       \
 1343|     54|  CONV;                                                                 \
 1344|     54|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 15, False: 39]
  ------------------
 1345|     54|}                                                                       \
_ZN16L32RecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     34|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     34|{                                                                       \
 1343|     34|  CONV;                                                                 \
 1344|     34|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 5, False: 29]
  ------------------
 1345|     34|}                                                                       \
_ZN16L64RecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     57|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     57|{                                                                       \
 1343|     57|  CONV;                                                                 \
 1344|     57|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 16, False: 41]
  ------------------
 1345|     57|}                                                                       \
_ZN15LPRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     54|{                                                                       \
 1343|     54|  CONV;                                                                 \
 1344|     54|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 1, False: 53]
  ------------------
 1345|     54|}                                                                       \
_ZN18EUI48RecordContentC2Ev:
 1166|     76|  EUI48RecordContent() = default;
_ZN18EUI64RecordContentC2Ev:
 1185|     33|  EUI64RecordContent() = default;
_ZN16APLRecordContentC2Ev:
 1216|    202|  APLRecordContent() = default;
_ZN16URIRecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    102|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    102|{                                                                       \
 1343|    102|  CONV;                                                                 \
 1344|    102|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 102]
  ------------------
 1345|    102|}                                                                       \
_ZN16CAARecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|    531|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|    531|{                                                                       \
 1343|    531|  CONV;                                                                 \
 1344|    531|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 531]
  ------------------
 1345|    531|}                                                                       \
_ZN20RESINFORecordContent9xfrPacketI12PacketReaderEEvRT_b:
 1341|     60|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
 1342|     60|{                                                                       \
 1343|     60|  CONV;                                                                 \
 1344|     60|  if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
  ------------------
  |  Branch (1344:7): [True: 0, False: 60]
  ------------------
 1345|     60|}                                                                       \
_ZN10NSECBitmapC2Ev:
  820|    901|  NSECBitmap(): d_bitset(nullptr)
  821|    901|  {
  822|    901|  }
_ZN10NSECBitmap3setEt:
  851|  39.0k|  {
  852|  39.0k|    if (!d_bitset) {
  ------------------
  |  Branch (852:9): [True: 37.7k, False: 1.26k]
  ------------------
  853|  37.7k|      if (d_set.size() >= 200) {
  ------------------
  |  Branch (853:11): [True: 126, False: 37.6k]
  ------------------
  854|    126|        migrateToBitSet();
  855|    126|      }
  856|  37.7k|    }
  857|  39.0k|    if (d_bitset) {
  ------------------
  |  Branch (857:9): [True: 1.39k, False: 37.6k]
  ------------------
  858|  1.39k|      d_bitset->set(type);
  859|  1.39k|    }
  860|  37.6k|    else {
  861|  37.6k|      d_set.insert(type);
  862|  37.6k|    }
  863|  39.0k|  }
_ZN10NSECBitmap15migrateToBitSetEv:
  891|    126|  {
  892|    126|    d_bitset = std::make_unique<std::bitset<nbTypes>>();
  893|  25.2k|    for (const auto& type : d_set) {
  ------------------
  |  Branch (893:27): [True: 25.2k, False: 126]
  ------------------
  894|  25.2k|      d_bitset->set(type);
  895|  25.2k|    }
  896|    126|    d_set.clear();
  897|    126|  }
_ZN17NSECRecordContentC2Ev:
  911|    589|  NSECRecordContent() = default;
_ZN18NSEC3RecordContentC2Ev:
  952|    187|  NSEC3RecordContent() = default;
_ZN23NSEC3PARAMRecordContentC2Ev:
 1035|     69|  NSEC3PARAMRecordContent() = default;
_ZN18CSYNCRecordContentC2Ev:
 1002|    125|  CSYNCRecordContent() = default;
_ZN16LOCRecordContentC2Ev:
 1063|    106|  LOCRecordContent() = default;

_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEEC2ERS4_RK7DNSNametth:
   43|  4.22k|  d_qname(qname), d_content(content)
   44|  4.22k|{
   45|  4.22k|  d_content.clear();
   46|  4.22k|  dnsheader dnsheader;
   47|       |
   48|  4.22k|  memset(&dnsheader, 0, sizeof(dnsheader));
   49|  4.22k|  dnsheader.id=0;
   50|  4.22k|  dnsheader.qdcount=htons(1);
   51|  4.22k|  dnsheader.opcode=opcode;
   52|       |
   53|  4.22k|  const uint8_t* ptr=(const uint8_t*)&dnsheader;
   54|  4.22k|  d_content.reserve(sizeof(dnsheader) + qname.wirelength() + sizeof(qtype) + sizeof(qclass));
   55|  4.22k|  d_content.resize(sizeof(dnsheader));
   56|  4.22k|  uint8_t* dptr=(&*d_content.begin());
   57|       |
   58|  4.22k|  memcpy(dptr, ptr, sizeof(dnsheader));
   59|  4.22k|  d_namepositions.reserve(16);
   60|  4.22k|  xfrName(qname, false);
   61|  4.22k|  xfr16BitInt(qtype);
   62|  4.22k|  xfr16BitInt(qclass);
   63|       |
   64|  4.22k|  if (d_content.size() > std::numeric_limits<decltype(d_truncatemarker)>::max()) {
  ------------------
  |  Branch (64:7): [True: 0, False: 4.22k]
  ------------------
   65|      0|    throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits<decltype(d_truncatemarker)>::max()) + " bytes");
   66|      0|  }
   67|  4.22k|  d_truncatemarker = d_content.size();
   68|  4.22k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11startRecordERK7DNSNametjtN17DNSResourceRecord5PlaceEb:
   77|  10.8k|{
   78|  10.8k|  d_compress = compress;
   79|  10.8k|  commit();
   80|  10.8k|  if (d_content.size() > std::numeric_limits<decltype(d_rollbackmarker)>::max()) {
  ------------------
  |  Branch (80:7): [True: 0, False: 10.8k]
  ------------------
   81|      0|    throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits<decltype(d_rollbackmarker)>::max()) + " bytes");
   82|      0|  }
   83|  10.8k|  d_rollbackmarker = d_content.size();
   84|       |
   85|  10.8k|  if (compress && !name.isRoot() && d_qname==name) {  // don't do the whole label compression thing if we *know* we can get away with "see question" - except when compressing the root
  ------------------
  |  Branch (85:7): [True: 9.91k, False: 909]
  |  Branch (85:19): [True: 6.41k, False: 3.50k]
  |  Branch (85:37): [True: 0, False: 6.41k]
  ------------------
   86|      0|    static const std::array<unsigned char, 2> marker{0xc0, 0x0c};
   87|      0|    d_content.insert(d_content.end(), reinterpret_cast<const char *>(marker.begin()), reinterpret_cast<const char *>(marker.end()));
   88|      0|  }
   89|  10.8k|  else {
   90|  10.8k|    xfrName(name, compress);
   91|  10.8k|  }
   92|  10.8k|  xfr16BitInt(qtype);
   93|  10.8k|  xfr16BitInt(qclass);
   94|  10.8k|  xfr32BitInt(ttl);
   95|  10.8k|  xfr16BitInt(0); // this will be the record size
   96|  10.8k|  d_recordplace = place;
   97|       |
   98|  10.8k|  d_sor = d_content.size(); // this will remind us where to stuff the record size
   99|  10.8k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE6addOptEtttRKNS1_INS0_4pairItNS0_12basic_stringIcNS0_11char_traitsIcEENS2_IcEEEEEENS2_ISC_EEEEh:
  102|    900|{
  103|    900|  uint32_t ttl=0;
  104|       |
  105|    900|  EDNS0Record stuff;
  106|       |
  107|    900|  stuff.version = version;
  108|    900|  stuff.extFlags = htons(ednsFlags);
  109|       |
  110|       |  /* RFC 6891 section 4 on the Extended RCode wire format
  111|       |   *    EXTENDED-RCODE
  112|       |   *        Forms the upper 8 bits of extended 12-bit RCODE (together with the
  113|       |   *        4 bits defined in [RFC1035].  Note that EXTENDED-RCODE value 0
  114|       |   *        indicates that an unextended RCODE is in use (values 0 through 15).
  115|       |   */
  116|       |  // XXX Should be check for extRCode > 1<<12 ?
  117|    900|  stuff.extRCode = extRCode>>4;
  118|    900|  if (extRCode != 0) { // As this trumps the existing RCODE
  ------------------
  |  Branch (118:7): [True: 0, False: 900]
  ------------------
  119|      0|    getHeader()->rcode = extRCode;
  120|      0|  }
  121|       |
  122|    900|  static_assert(sizeof(EDNS0Record) == sizeof(ttl), "sizeof(EDNS0Record) must match sizeof(ttl)");
  123|    900|  memcpy(&ttl, &stuff, sizeof(stuff));
  124|       |
  125|    900|  ttl=ntohl(ttl); // will be reversed later on
  126|       |
  127|    900|  startRecord(g_rootdnsname, QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false);
  128|  50.6k|  for(auto const &option : options) {
  ------------------
  |  Branch (128:26): [True: 50.6k, False: 900]
  ------------------
  129|  50.6k|    xfr16BitInt(option.first);
  130|  50.6k|    xfr16BitInt(option.second.length());
  131|  50.6k|    xfrBlob(option.second);
  132|  50.6k|  }
  133|    900|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE6commitEv:
  574|  15.0k|{
  575|  15.0k|  if (d_sor == 0) {
  ------------------
  |  Branch (575:7): [True: 4.22k, False: 10.8k]
  ------------------
  576|  4.22k|    return;
  577|  4.22k|  }
  578|       |
  579|  10.8k|  if (d_sor < 2 || d_sor > d_content.size()) {
  ------------------
  |  Branch (579:7): [True: 0, False: 10.8k]
  |  Branch (579:20): [True: 0, False: 10.8k]
  ------------------
  580|      0|    throw std::range_error("Invalid start of record when trying to build a packet: " + std::to_string(d_sor) + " / " + std::to_string(d_content.size()));
  581|      0|  }
  582|       |
  583|  10.8k|  if (d_content.size() > std::numeric_limits<uint16_t>::max()) {
  ------------------
  |  Branch (583:7): [True: 57, False: 10.7k]
  ------------------
  584|     57|    throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits<uint16_t>::max()) + " bytes");
  585|     57|  }
  586|       |
  587|  10.7k|  uint16_t rlen = d_content.size() - d_sor;
  588|  10.7k|  d_content.at(d_sor-2) = rlen >> 8;
  589|  10.7k|  d_content.at(d_sor-1) = rlen & 0xff;
  590|  10.7k|  d_sor = 0;
  591|  10.7k|  auto* dh = reinterpret_cast<dnsheader*>( &*d_content.begin());
  592|  10.7k|  switch(d_recordplace) {
  ------------------
  |  Branch (592:10): [True: 10.7k, False: 0]
  ------------------
  593|      0|  case DNSResourceRecord::QUESTION:
  ------------------
  |  Branch (593:3): [True: 0, False: 10.7k]
  ------------------
  594|      0|    dh->qdcount = htons(ntohs(dh->qdcount) + 1);
  595|      0|    break;
  596|  9.90k|  case DNSResourceRecord::ANSWER:
  ------------------
  |  Branch (596:3): [True: 9.90k, False: 852]
  ------------------
  597|  9.90k|    dh->ancount = htons(ntohs(dh->ancount) + 1);
  598|  9.90k|    break;
  599|      0|  case DNSResourceRecord::AUTHORITY:
  ------------------
  |  Branch (599:3): [True: 0, False: 10.7k]
  ------------------
  600|      0|    dh->nscount = htons(ntohs(dh->nscount) + 1);
  601|      0|    break;
  602|    852|  case DNSResourceRecord::ADDITIONAL:
  ------------------
  |  Branch (602:3): [True: 852, False: 9.90k]
  ------------------
  603|    852|    dh->arcount = htons(ntohs(dh->arcount) + 1);
  604|    852|    break;
  605|  10.7k|  }
  606|       |
  607|  10.7k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11xfr32BitIntEm:
  155|  10.8k|{
  156|  10.8k|  if (val > std::numeric_limits<uint32_t>::max()) {
  ------------------
  |  Branch (156:7): [True: 0, False: 10.8k]
  ------------------
  157|      0|    throw runtime_error("Value too large to fit in 32 bits");
  158|      0|  }
  159|  10.8k|  uint32_t rval=htonl(static_cast<uint32_t>(val));
  160|  10.8k|  uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);
  161|  10.8k|  d_content.insert(d_content.end(), ptr, ptr+4);
  162|  10.8k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11xfr16BitIntEm:
  165|   142k|{
  166|   142k|  if (val > std::numeric_limits<uint16_t>::max()) {
  ------------------
  |  Branch (166:7): [True: 0, False: 142k]
  ------------------
  167|      0|    throw runtime_error("Value too large to fit in 16 bits");
  168|      0|  }
  169|   142k|  uint16_t rval=htons(static_cast<uint16_t>(val));
  170|   142k|  uint8_t* ptr=reinterpret_cast<uint8_t*>(&rval);
  171|   142k|  d_content.insert(d_content.end(), ptr, ptr+2);
  172|   142k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE7xfrNameERK7DNSNameb:
  395|  15.0k|{
  396|  15.0k|  if(l_verbose)
  ------------------
  |  Branch (396:6): [Folded, False: 15.0k]
  ------------------
  397|      0|    cout<<"Wants to write "<<name<<", compress="<<compress<<", canonic="<<d_canonic<<", LC="<<d_lowerCase<<endl;
  398|  15.0k|  if(d_canonic || d_lowerCase)   // d_lowerCase implies canonic
  ------------------
  |  Branch (398:6): [True: 0, False: 15.0k]
  |  Branch (398:19): [True: 0, False: 15.0k]
  ------------------
  399|      0|    compress=false;
  400|       |
  401|  15.0k|  if(name.empty() || name.isRoot()) { // for speed
  ------------------
  |  Branch (401:6): [True: 0, False: 15.0k]
  |  Branch (401:22): [True: 8.61k, False: 6.41k]
  ------------------
  402|  8.61k|    d_content.push_back(0);
  403|  8.61k|    return;
  404|  8.61k|  }
  405|       |
  406|  6.41k|  uint16_t li=0;
  407|  6.41k|  uint16_t matchlen=0;
  408|  6.41k|  if(d_compress && compress && (li=lookupName(name, &matchlen)) && li < maxCompressionOffset) {
  ------------------
  |  Branch (408:6): [True: 6.41k, False: 0]
  |  Branch (408:20): [True: 6.41k, False: 0]
  |  Branch (408:32): [True: 3.39k, False: 3.01k]
  |  Branch (408:68): [True: 3.39k, False: 0]
  ------------------
  409|  3.39k|    const auto& dns=name.getStorage();
  410|  3.39k|    if(l_verbose)
  ------------------
  |  Branch (410:8): [Folded, False: 3.39k]
  ------------------
  411|      0|      cout<<"Found a substring of "<<matchlen<<" bytes from the back, offset: "<<li<<", dnslen: "<<dns.size()<<endl;
  412|       |    // found a substring, if www.powerdns.com matched powerdns.com, we get back matchlen = 13
  413|       |
  414|  3.39k|    unsigned int pos=d_content.size();
  415|  3.39k|    if(pos < maxCompressionOffset && matchlen != dns.size()) {
  ------------------
  |  Branch (415:8): [True: 3.23k, False: 160]
  |  Branch (415:38): [True: 1.78k, False: 1.45k]
  ------------------
  416|  1.78k|      if(l_verbose)
  ------------------
  |  Branch (416:10): [Folded, False: 1.78k]
  ------------------
  417|      0|        cout<<"Inserting pos "<<pos<<" for "<<name<<" for compressed case"<<endl;
  418|  1.78k|      d_namepositions.push_back(pos);
  419|  1.78k|    }
  420|       |
  421|  3.39k|    if(l_verbose)
  ------------------
  |  Branch (421:8): [Folded, False: 3.39k]
  ------------------
  422|      0|      cout<<"Going to write unique part: '"<<makeHexDump(string(dns.c_str(), dns.c_str() + dns.size() - matchlen)) <<"'"<<endl;
  423|  3.39k|    d_content.insert(d_content.end(), (const unsigned char*)dns.c_str(), (const unsigned char*)dns.c_str() + dns.size() - matchlen);
  424|  3.39k|    uint16_t offset=li;
  425|  3.39k|    offset|=0xc000;
  426|       |
  427|  3.39k|    d_content.push_back((char)(offset >> 8));
  428|  3.39k|    d_content.push_back((char)(offset & 0xff));
  429|  3.39k|  }
  430|  3.01k|  else {
  431|  3.01k|    unsigned int pos=d_content.size();
  432|  3.01k|    if(l_verbose)
  ------------------
  |  Branch (432:8): [Folded, False: 3.01k]
  ------------------
  433|      0|      cout<<"Found nothing, we are at pos "<<pos<<", inserting whole name"<<endl;
  434|  3.01k|    if(pos < maxCompressionOffset) {
  ------------------
  |  Branch (434:8): [True: 2.83k, False: 188]
  ------------------
  435|  2.83k|      if(l_verbose)
  ------------------
  |  Branch (435:10): [Folded, False: 2.83k]
  ------------------
  436|      0|        cout<<"Inserting pos "<<pos<<" for "<<name<<" for uncompressed case"<<endl;
  437|  2.83k|      d_namepositions.push_back(pos);
  438|  2.83k|    }
  439|       |
  440|  3.01k|    std::unique_ptr<DNSName> lc;
  441|  3.01k|    if(d_lowerCase)
  ------------------
  |  Branch (441:8): [True: 0, False: 3.01k]
  ------------------
  442|      0|      lc = make_unique<DNSName>(name.makeLowerCase());
  443|       |
  444|  3.01k|    const DNSName::string_t& raw = (lc ? *lc : name).getStorage();
  ------------------
  |  Branch (444:37): [True: 0, False: 3.01k]
  ------------------
  445|  3.01k|    if(l_verbose)
  ------------------
  |  Branch (445:8): [Folded, False: 3.01k]
  ------------------
  446|      0|      cout<<"Writing out the whole thing "<<makeHexDump(string(raw.c_str(),  raw.c_str() + raw.length()))<<endl;
  447|  3.01k|    d_content.insert(d_content.end(), raw.c_str(), raw.c_str() + raw.size());
  448|  3.01k|  }
  449|  6.41k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE7xfrBlobERKNS0_12basic_stringIcNS0_11char_traitsIcEENS2_IcEEEEi:
  452|  60.5k|{
  453|  60.5k|  const uint8_t* ptr=reinterpret_cast<const uint8_t*>(blob.c_str());
  454|  60.5k|  d_content.insert(d_content.end(), ptr, ptr+blob.size());
  455|  60.5k|}
_ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE10lookupNameERK7DNSNamePt:
  229|  6.41k|{
  230|       |  // iterate over the written labels, see if we find a match
  231|  6.41k|  const auto& raw = name.getStorage();
  232|       |
  233|       |  /* name might be a.root-servers.net, we need to be able to benefit from finding:
  234|       |     b.root-servers.net, or even:
  235|       |     b\xc0\x0c
  236|       |  */
  237|  6.41k|  unsigned int bestpos=0;
  238|  6.41k|  *matchLen = 0;
  239|       |
  240|       |  // positions of each label in the name we are trying to compress
  241|  6.41k|  boost::container::static_vector<uint16_t, 34> positionsInName;
  242|       |  // positions of labels in the packet we are building
  243|  6.41k|  boost::container::static_vector<uint16_t, 34> positionsInPacket;
  244|       |
  245|  6.41k|  try {
  246|  23.5k|    for(auto riter= raw.cbegin(); riter < raw.cend(); ) {
  ------------------
  |  Branch (246:35): [True: 23.5k, False: 0]
  ------------------
  247|  23.5k|      if (*riter == 0) {
  ------------------
  |  Branch (247:11): [True: 6.41k, False: 17.1k]
  ------------------
  248|  6.41k|        break;
  249|  6.41k|      }
  250|  17.1k|      positionsInName.push_back(riter - raw.cbegin());
  251|  17.1k|      riter += *riter + 1;
  252|  17.1k|    }
  253|  6.41k|  }
  254|  6.41k|  catch (const std::bad_alloc& ba) {
  255|      0|    if (l_verbose) {
  ------------------
  |  Branch (255:9): [Folded, False: 0]
  ------------------
  256|      0|      cout << "Domain " << name << " too large to compress" << endl;
  257|      0|    }
  258|      0|    return 0;
  259|      0|  }
  260|       |
  261|  6.41k|  if (l_verbose) {
  ------------------
  |  Branch (261:7): [Folded, False: 6.41k]
  ------------------
  262|      0|    cout<<"Input vector for lookup "<<name<<": ";
  263|      0|    for (const auto n : positionsInName) {
  ------------------
  |  Branch (263:23): [True: 0, False: 0]
  ------------------
  264|      0|      cout << n << " ";
  265|      0|    }
  266|      0|    cout<<endl;
  267|      0|    cout<<makeHexDump(string(raw.c_str(), raw.c_str()+raw.size()))<<endl;
  268|      0|  }
  269|       |
  270|  6.41k|  if (l_verbose) {
  ------------------
  |  Branch (270:7): [Folded, False: 6.41k]
  ------------------
  271|      0|    cout << "Have " << d_namepositions.size() << " to ponder" << endl;
  272|      0|  }
  273|       |
  274|  6.41k|  int counter=1;
  275|  6.41k|  for (const auto positionInPacket : d_namepositions) {
  ------------------
  |  Branch (275:36): [True: 5.64k, False: 4.94k]
  ------------------
  276|       |    // here it's a bit tricky because the names might be compressed,
  277|       |    // so we will gather all labels composing the name, following
  278|       |    // pointers if needed
  279|       |    // for example if there is an uncompressed \1a\1b\1c\0 we will store
  280|       |    // the position of \1a, \1b, \1c
  281|       |    // if there is instead \1a followed by a pointer to \1b\1c\0 earlier
  282|       |    // in the packet we will store the position of \1a, \1b, \1c as well
  283|       |    // they will just be disjoint
  284|  5.64k|    if (l_verbose) {
  ------------------
  |  Branch (284:9): [Folded, False: 5.64k]
  ------------------
  285|      0|      cout<<"Pos: "<<positionInPacket<<", "<<d_content.size()<<endl;
  286|      0|      DNSName pname(reinterpret_cast<const char*>(d_content.data()), d_content.size(), positionInPacket, true); // only for debugging
  287|      0|      cout<<"Looking at '"<<pname<<"' in packet at position "<<positionInPacket<<"/"<<d_content.size()<<", option "<<counter<<"/"<<d_namepositions.size()<<endl;
  288|      0|      ++counter;
  289|      0|    }
  290|  5.64k|    size_t pointerQuota = 50U;
  291|       |    // memcmp here makes things _slower_
  292|  5.64k|    positionsInPacket.clear();
  293|  5.64k|    try {
  294|  23.8k|      for (auto iter = d_content.cbegin() + positionInPacket; iter < d_content.cend() && pointerQuota > 0;) {
  ------------------
  |  Branch (294:63): [True: 23.8k, False: 0]
  |  Branch (294:63): [True: 23.8k, False: 0]
  |  Branch (294:90): [True: 23.8k, False: 0]
  ------------------
  295|  23.8k|        uint8_t labelLength = *iter;
  296|  23.8k|        const uint16_t currentPos = (iter - d_content.cbegin());
  297|  23.8k|        if (l_verbose) {
  ------------------
  |  Branch (297:13): [Folded, False: 23.8k]
  ------------------
  298|      0|          cout << "Found label length: " << std::to_string(labelLength) << " at " << currentPos << endl;
  299|      0|        }
  300|  23.8k|        if (labelLength & 0xc0) {
  ------------------
  |  Branch (300:13): [True: 2.54k, False: 21.3k]
  ------------------
  301|  2.54k|          uint16_t npos = 0x100*(labelLength & (~0xc0)) + *++iter;
  302|       |          // check against going forward
  303|  2.54k|          if (npos >= currentPos || npos < sizeof(dnsheader)) {
  ------------------
  |  Branch (303:15): [True: 0, False: 2.54k]
  |  Branch (303:37): [True: 0, False: 2.54k]
  ------------------
  304|       |            /* something is not right */
  305|      0|            break;
  306|      0|          }
  307|       |
  308|       |          // jump to the target of the pointer
  309|  2.54k|          iter = d_content.begin() + npos;
  310|  2.54k|          if (l_verbose) {
  ------------------
  |  Branch (310:15): [Folded, False: 2.54k]
  ------------------
  311|      0|            cout << "Is compressed label to newpos " << npos << ", going there" << endl;
  312|      0|          }
  313|       |
  314|  2.54k|          if (pointerQuota >= 1) {
  ------------------
  |  Branch (314:15): [True: 2.54k, False: 0]
  ------------------
  315|  2.54k|            pointerQuota--;
  316|  2.54k|            continue;
  317|  2.54k|          }
  318|       |
  319|       |          // out of pointer quota, let's stop there
  320|      0|          break;
  321|  2.54k|        }
  322|       |
  323|  21.3k|        if (labelLength == 0) {
  ------------------
  |  Branch (323:13): [True: 5.57k, False: 15.7k]
  ------------------
  324|  5.57k|          break;
  325|  5.57k|        }
  326|       |
  327|  15.7k|        if (currentPos >= maxCompressionOffset) {
  ------------------
  |  Branch (327:13): [True: 65, False: 15.7k]
  ------------------
  328|     65|          break; // compression pointers cannot point here
  329|     65|        }
  330|       |
  331|  15.7k|        positionsInPacket.push_back(currentPos);
  332|       |        // jump to the next label
  333|  15.7k|        iter += labelLength + 1;
  334|  15.7k|      }
  335|  5.64k|    }
  336|  5.64k|    catch (const std::bad_alloc& ba) {
  337|      0|      if (l_verbose) {
  ------------------
  |  Branch (337:11): [Folded, False: 0]
  ------------------
  338|      0|        cout << "Domain " << name << " too large to compress" << endl;
  339|      0|      }
  340|      0|      continue;
  341|      0|    }
  342|       |
  343|  5.64k|    if (l_verbose) {
  ------------------
  |  Branch (343:9): [Folded, False: 5.64k]
  ------------------
  344|      0|      cout<<"Packet vector: "<<endl;
  345|      0|      for (const auto n : positionsInPacket) {
  ------------------
  |  Branch (345:25): [True: 0, False: 0]
  ------------------
  346|      0|        cout << n << " ";
  347|      0|      }
  348|      0|      cout<<endl;
  349|      0|    }
  350|       |
  351|  5.64k|    auto positionInNameIter = positionsInName.crbegin();
  352|  5.64k|    auto positionInPacketIter = positionsInPacket.crbegin();
  353|  5.64k|    unsigned int cmatchlen=1;
  354|  14.4k|    for(; positionInNameIter != positionsInName.crend() && positionInPacketIter != positionsInPacket.crend(); ++positionInNameIter, ++positionInPacketIter) {
  ------------------
  |  Branch (354:11): [True: 14.4k, False: 0]
  |  Branch (354:11): [True: 13.7k, False: 695]
  |  Branch (354:60): [True: 13.7k, False: 695]
  ------------------
  355|       |      // positionInNameIter is an offset in raw, pvect an offset in packet
  356|  13.7k|      uint8_t nlen = raw[*positionInNameIter];
  357|  13.7k|      uint8_t plen = d_content[*positionInPacketIter];
  358|       |
  359|  13.7k|      if (l_verbose) {
  ------------------
  |  Branch (359:11): [Folded, False: 13.7k]
  ------------------
  360|      0|        cout << "nlnen=" << (int)nlen << ", plen=" << (int)plen << endl;
  361|      0|      }
  362|       |
  363|  13.7k|      if (nlen != plen) {
  ------------------
  |  Branch (363:11): [True: 2.94k, False: 10.7k]
  ------------------
  364|  2.94k|        break;
  365|  2.94k|      }
  366|       |
  367|  10.7k|      auto rawpart = std::string_view(raw.c_str() + *positionInNameIter + 1, nlen); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  368|  10.7k|      auto pktpart = std::string_view((const char*)&d_content[*positionInPacketIter] + 1, nlen); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  369|  10.7k|      if (pdns_ilexicographical_compare_three_way(rawpart, pktpart) != 0) {
  ------------------
  |  Branch (369:11): [True: 529, False: 10.2k]
  ------------------
  370|    529|        if (l_verbose) {
  ------------------
  |  Branch (370:13): [Folded, False: 529]
  ------------------
  371|      0|          cout << "Mismatch: " << rawpart << " != " << pktpart << endl;
  372|      0|        }
  373|    529|        break;
  374|    529|      }
  375|       |
  376|  10.2k|      cmatchlen += nlen + 1;
  377|  10.2k|      if (cmatchlen == raw.length()) { // have matched all of it, can't improve
  ------------------
  |  Branch (377:11): [True: 1.47k, False: 8.78k]
  ------------------
  378|  1.47k|        if (l_verbose) {
  ------------------
  |  Branch (378:13): [Folded, False: 1.47k]
  ------------------
  379|      0|          cout << "Stopping search, matched whole name" << endl;
  380|      0|        }
  381|       |
  382|  1.47k|        *matchLen = cmatchlen;
  383|  1.47k|        return *positionInPacketIter;
  384|  1.47k|      }
  385|  10.2k|    }
  386|  4.17k|    if (positionInPacketIter != positionsInPacket.crbegin() && *matchLen < cmatchlen) {
  ------------------
  |  Branch (386:9): [True: 4.10k, False: 65]
  |  Branch (386:9): [True: 2.75k, False: 1.41k]
  |  Branch (386:64): [True: 2.75k, False: 1.35k]
  ------------------
  387|  2.75k|      *matchLen = cmatchlen;
  388|  2.75k|      bestpos = *--positionInPacketIter;
  389|  2.75k|    }
  390|  4.17k|  }
  391|  4.94k|  return bestpos;
  392|  6.41k|}

_Z14getEDNSOptionsPKcmRNSt3__13mapIt14EDNSOptionViewNS1_4lessItEENS1_9allocatorINS1_4pairIKtS3_EEEEEE:
  160|  4.22k|{
  161|  4.22k|  size_t pos = 0;
  162|  4.22k|  if (optRR == nullptr || len < DNS_RDLENGTH_SIZE) {
  ------------------
  |  Branch (162:7): [True: 0, False: 4.22k]
  |  Branch (162:27): [True: 2, False: 4.21k]
  ------------------
  163|      2|    return EINVAL;
  164|      2|  }
  165|       |
  166|  4.21k|  const uint16_t rdLen = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]);
  167|  4.21k|  size_t rdPos = 0;
  168|  4.21k|  pos += DNS_RDLENGTH_SIZE;
  169|  4.21k|  if ((pos + rdLen) > len) {
  ------------------
  |  Branch (169:7): [True: 3.29k, False: 925]
  ------------------
  170|  3.29k|    return EINVAL;
  171|  3.29k|  }
  172|       |
  173|  33.6k|  while (len >= (pos + EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE) && rdLen >= (rdPos + EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE)) {
  ------------------
  |  Branch (173:10): [True: 33.5k, False: 95]
  |  Branch (173:76): [True: 33.2k, False: 247]
  ------------------
  174|  33.2k|    const uint16_t optionCode = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]);
  175|  33.2k|    pos += EDNS_OPTION_CODE_SIZE;
  176|  33.2k|    rdPos += EDNS_OPTION_CODE_SIZE;
  177|  33.2k|    const uint16_t optionLen = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]);
  178|  33.2k|    pos += EDNS_OPTION_LENGTH_SIZE;
  179|  33.2k|    rdPos += EDNS_OPTION_LENGTH_SIZE;
  180|  33.2k|    if (optionLen > (rdLen - rdPos) || optionLen > (len - pos)) {
  ------------------
  |  Branch (180:9): [True: 583, False: 32.7k]
  |  Branch (180:40): [True: 0, False: 32.7k]
  ------------------
  181|    583|      return EINVAL;
  182|    583|    }
  183|  32.7k|    EDNSOptionViewValue value;
  184|  32.7k|    value.content = optRR + pos;
  185|  32.7k|    value.size = optionLen;
  186|  32.7k|    options[optionCode].values.push_back(value);
  187|       |
  188|       |    /* skip this option */
  189|  32.7k|    pos += optionLen;
  190|  32.7k|    rdPos += optionLen;
  191|  32.7k|  }
  192|       |
  193|    342|  return 0;
  194|    925|}
_Z25getEDNSOptionsFromContentRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_6vectorINS_4pairItS5_EENS3_ISA_EEEE:
  197|  4.22k|{
  198|  4.22k|  size_t pos = 0;
  199|  4.22k|  const size_t contentLength = content.size();
  200|       |
  201|  54.8k|  while (pos < contentLength && (contentLength - pos) >= (EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE)) {
  ------------------
  |  Branch (201:10): [True: 54.6k, False: 225]
  |  Branch (201:33): [True: 54.4k, False: 191]
  ------------------
  202|  54.4k|    uint16_t code = (static_cast<unsigned char>(content.at(pos)) * 256) + static_cast<unsigned char>(content.at(pos + 1));
  203|  54.4k|    pos += EDNS_OPTION_CODE_SIZE;
  204|  54.4k|    uint16_t len = (static_cast<unsigned char>(content.at(pos)) * 256) + static_cast<unsigned char>(content.at(pos + 1));
  205|  54.4k|    pos += EDNS_OPTION_LENGTH_SIZE;
  206|       |
  207|  54.4k|    if (pos > contentLength || len > (contentLength - pos)) {
  ------------------
  |  Branch (207:9): [True: 0, False: 54.4k]
  |  Branch (207:32): [True: 3.80k, False: 50.6k]
  ------------------
  208|  3.80k|      return false;
  209|  3.80k|    }
  210|       |
  211|  50.6k|    options.emplace_back(code, content.substr(pos, len));
  212|  50.6k|    pos += len;
  213|  50.6k|  }
  214|       |
  215|    416|  return true;
  216|  4.22k|}

LLVMFuzzerTestOneInput:
   46|  4.22k|{
   47|  4.22k|  static bool initialized = false;
   48|       |
   49|  4.22k|  if (!initialized) {
  ------------------
  |  Branch (49:7): [True: 1, False: 4.22k]
  ------------------
   50|      1|    init();
   51|      1|    initialized = true;
   52|      1|  }
   53|       |
   54|  4.22k|  if (size > std::numeric_limits<uint16_t>::max()) {
  ------------------
  |  Branch (54:7): [True: 5, False: 4.22k]
  ------------------
   55|      5|    return 0;
   56|      5|  }
   57|       |
   58|       |  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
   59|  4.22k|  const char* chars = reinterpret_cast<const char*>(data);
   60|       |
   61|  4.22k|  try {
   62|       |    // 1) Feed the raw, untrusted bytes straight to the EDNS OPT option parsers:
   63|       |    //    the option TLV decoder in ednsoptions.cc is otherwise unreached.
   64|  4.22k|    EDNSOptionViewMap viewOptions;
   65|  4.22k|    (void)getEDNSOptions(chars, size, viewOptions);
   66|       |
   67|  4.22k|    std::vector<std::pair<uint16_t, std::string>> options;
   68|  4.22k|    (void)getEDNSOptionsFromContent(std::string(chars, size), options);
   69|       |
   70|       |    // 2) Drive DNSPacketWriter with attacker-controlled structures (several
   71|       |    //    records, attacker rdata, name compression, EDNS OPT writing), the
   72|       |    //    full-packet writer paths that the parse/record fuzzers never reach.
   73|  4.22k|    size_t pos = 0;
   74|       |    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   75|  4.22k|    const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; };
   76|  4.22k|    const auto getU16 = [&]() -> uint16_t {
   77|  4.22k|      const uint16_t highV = getU8();
   78|  4.22k|      return static_cast<uint16_t>((highV << 8) | getU8());
   79|  4.22k|    };
   80|       |
   81|  4.22k|    const uint16_t qtype = getU16();
   82|  4.22k|    const DNSName qname(".");
   83|  4.22k|    std::vector<uint8_t> packet;
   84|  4.22k|    DNSPacketWriter writer(packet, qname, qtype);
   85|       |
   86|  4.22k|    static const std::array<const char*, 4> suffixes{".", "example.com.", "a.example.com.", "powerdns.com."};
   87|       |
   88|  4.22k|    const unsigned int records = getU8() % 8U;
   89|  14.1k|    for (unsigned int i = 0; i < records && pos < size; ++i) {
  ------------------
  |  Branch (89:30): [True: 13.0k, False: 1.07k]
  |  Branch (89:45): [True: 9.92k, False: 3.14k]
  ------------------
   90|       |      // A valid name sharing one of a few suffixes (so the name-compression
   91|       |      // paths fire) with an attacker-controlled first label.
   92|  9.92k|      const uint8_t labelLen = getU8() % 32U;
   93|  9.92k|      std::string label;
   94|  41.6k|      for (uint8_t j = 0; j < labelLen && pos < size; ++j) {
  ------------------
  |  Branch (94:27): [True: 31.9k, False: 9.73k]
  |  Branch (94:43): [True: 31.7k, False: 192]
  ------------------
   95|  31.7k|        label.push_back(static_cast<char>('a' + (getU8() % 26)));
   96|  31.7k|      }
   97|  9.92k|      const std::string suffix = suffixes.at(getU8() % suffixes.size());
   98|  9.92k|      DNSName name{};
   99|  9.92k|      try {
  100|  9.92k|        if (label.empty()) {
  ------------------
  |  Branch (100:13): [True: 7.13k, False: 2.78k]
  ------------------
  101|  7.13k|          name = DNSName(suffix);
  102|  7.13k|        }
  103|  2.78k|        else {
  104|  2.78k|          label.append(".");
  105|  2.78k|          label.append(suffix);
  106|  2.78k|          name = DNSName(label);
  107|  2.78k|        }
  108|  9.92k|      }
  109|  9.92k|      catch (...) {
  110|    509|        name = qname;
  111|    509|      }
  112|       |
  113|  9.92k|      const uint16_t rtype = getU16();
  114|  9.92k|      const uint16_t rdlen = getU16();
  115|  9.92k|      std::string rdata;
  116|  11.9M|      for (uint16_t j = 0; j < rdlen && pos < size; ++j) {
  ------------------
  |  Branch (116:28): [True: 11.9M, False: 7.36k]
  |  Branch (116:41): [True: 11.9M, False: 2.56k]
  ------------------
  117|  11.9M|        rdata.push_back(static_cast<char>(getU8()));
  118|  11.9M|      }
  119|       |
  120|  9.92k|      writer.startRecord(name, rtype);
  121|  9.92k|      writer.xfrBlob(rdata);
  122|  9.92k|    }
  123|       |
  124|       |    // EDNS OPT writing fed with the attacker-parsed option vector.
  125|  4.22k|    if (!options.empty()) {
  ------------------
  |  Branch (125:9): [True: 900, False: 3.32k]
  ------------------
  126|    900|      DNSPacketWriter::optvect_t optvect;
  127|  50.6k|      for (const auto& option : options) {
  ------------------
  |  Branch (127:31): [True: 50.6k, False: 900]
  ------------------
  128|  50.6k|        optvect.emplace_back(option.first, option.second);
  129|  50.6k|      }
  130|    900|      writer.addOpt(1232, 0, 0, optvect);
  131|    900|    }
  132|  4.22k|    writer.commit();
  133|       |
  134|       |    // Re-parse the writer's own output.
  135|  4.22k|    if (!packet.empty()) {
  ------------------
  |  Branch (135:9): [True: 4.16k, False: 57]
  ------------------
  136|       |      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  137|  4.16k|      MOADNSParser reparse(false, reinterpret_cast<const char*>(packet.data()), packet.size());
  138|  4.16k|    }
  139|  4.22k|  }
  140|       |  // NOLINTNEXTLINE(bugprone-empty-catch)
  141|  4.22k|  catch (const std::exception& e) {
  142|  1.68k|  }
  143|       |  // NOLINTNEXTLINE(bugprone-empty-catch)
  144|  4.22k|  catch (const PDNSException& e) {
  145|      0|  }
  146|       |
  147|  4.22k|  return 0;
  148|  4.22k|}
fuzz_dnspacketroundtrip.cc:_ZL4initv:
   39|      1|{
   40|      1|  reportAllTypes();
   41|      1|}
fuzz_dnspacketroundtrip.cc:_ZZ22LLVMFuzzerTestOneInputENK3$_1clEv:
   76|  24.0k|    const auto getU16 = [&]() -> uint16_t {
   77|  24.0k|      const uint16_t highV = getU8();
   78|  24.0k|      return static_cast<uint16_t>((highV << 8) | getU8());
   79|  24.0k|    };
fuzz_dnspacketroundtrip.cc:_ZZ22LLVMFuzzerTestOneInputENK3$_0clEv:
   75|  12.0M|    const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; };
  ------------------
  |  Branch (75:50): [True: 12.0M, False: 3.56k]
  ------------------

_ZN12ComboAddressC2Ev:
  212|  63.5k|  {
  213|       |    sin4.sin_family = AF_INET;
  214|  63.5k|    sin4.sin_addr.s_addr = 0;
  215|  63.5k|    sin4.sin_port = 0;
  216|  63.5k|    sin6.sin6_scope_id = 0;
  217|  63.5k|    sin6.sin6_flowinfo = 0;
  218|  63.5k|  }
_ZNK12ComboAddress6isIPv6Ev:
  263|    361|  {
  264|       |    return sin4.sin_family == AF_INET6;
  265|    361|  }
_ZNK12ComboAddress6isIPv4Ev:
  267|  31.3k|  {
  268|       |    return sin4.sin_family == AF_INET;
  269|  31.3k|  }
_Z23makeComboAddressFromRawhPKcm:
  661|  31.7k|{
  662|  31.7k|  ComboAddress address;
  663|       |
  664|  31.7k|  if (version == 4) {
  ------------------
  |  Branch (664:7): [True: 31.3k, False: 361]
  ------------------
  665|  31.3k|    address.sin4.sin_family = AF_INET;
  666|  31.3k|    if (len != sizeof(address.sin4.sin_addr)) {
  ------------------
  |  Branch (666:9): [True: 0, False: 31.3k]
  ------------------
  667|      0|      throw NetmaskException("invalid raw address length");
  668|      0|    }
  669|  31.3k|    memcpy(&address.sin4.sin_addr, raw, sizeof(address.sin4.sin_addr));
  670|  31.3k|  }
  671|    361|  else if (version == 6) {
  ------------------
  |  Branch (671:12): [True: 361, False: 0]
  ------------------
  672|    361|    address.sin6.sin6_family = AF_INET6;
  673|    361|    if (len != sizeof(address.sin6.sin6_addr)) {
  ------------------
  |  Branch (673:9): [True: 0, False: 361]
  ------------------
  674|      0|      throw NetmaskException("invalid raw address length");
  675|      0|    }
  676|    361|    memcpy(&address.sin6.sin6_addr, raw, sizeof(address.sin6.sin6_addr));
  677|    361|  }
  678|      0|  else {
  679|      0|    throw NetmaskException("invalid address family");
  680|      0|  }
  681|       |
  682|  31.7k|  return address;
  683|  31.7k|}
_Z23makeComboAddressFromRawhRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  686|  31.7k|{
  687|  31.7k|  return makeComboAddressFromRaw(version, str.c_str(), str.size());
  688|  31.7k|}

_Z11makeHexDumpRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEES7_:
  551|    202|{
  552|    202|  std::array<char, 5> tmp{};
  553|    202|  string ret;
  554|    202|  ret.reserve(static_cast<size_t>(str.size() * (2 + sep.size())));
  555|       |
  556|   490k|  for (char index : str) {
  ------------------
  |  Branch (556:19): [True: 490k, False: 202]
  ------------------
  557|   490k|    snprintf(tmp.data(), tmp.size(), "%02x", static_cast<unsigned char>(index));
  558|   490k|    ret += tmp.data();
  559|   490k|    ret += sep;
  560|   490k|  }
  561|    202|  return ret;
  562|    202|}

_ZN10NSECBitmap10fromPacketER12PacketReader:
   99|    806|{
  100|    806|  string bitmap;
  101|    806|  pr.xfrBlob(bitmap);
  102|       |
  103|       |  // 00 06 20 00 00 00 00 03  -> NS RRSIG NSEC  ( 2, 46, 47 ) counts from left
  104|    806|  if (bitmap.empty()) {
  ------------------
  |  Branch (104:7): [True: 310, False: 496]
  ------------------
  105|    310|    return;
  106|    310|  }
  107|       |
  108|    496|  if (bitmap.size() < 2) {
  ------------------
  |  Branch (108:7): [True: 4, False: 492]
  ------------------
  109|      4|    throw MOADNSException("NSEC record with impossibly small bitmap");
  110|      4|  }
  111|       |
  112|    492|  size_t position = 0;
  113|    492|  std::optional<uint8_t> lastWindowSeen{std::nullopt};
  114|  1.29k|  while (position + 1 < bitmap.size()) {
  ------------------
  |  Branch (114:10): [True: 946, False: 348]
  ------------------
  115|    946|    const auto window = static_cast<uint8_t>(bitmap.at(position++));
  116|    946|    const auto blen = static_cast<uint8_t>(bitmap.at(position++));
  117|       |
  118|       |    // end if zero padding and ensure packet length
  119|    946|    if (window == 0 && blen == 0) {
  ------------------
  |  Branch (119:9): [True: 189, False: 757]
  |  Branch (119:24): [True: 50, False: 139]
  ------------------
  120|     50|      break;
  121|     50|    }
  122|       |
  123|       |    // rfc4034: "Blocks are present in the NSEC RR RDATA in increasing numerical order."
  124|    896|    if (lastWindowSeen.has_value() && lastWindowSeen.value() >= window) {
  ------------------
  |  Branch (124:9): [True: 426, False: 470]
  |  Branch (124:39): [True: 53, False: 373]
  ------------------
  125|     53|      throw MOADNSException("NSEC record with out of order blocks");
  126|     53|    }
  127|       |
  128|    843|    if (blen > 32) {
  ------------------
  |  Branch (128:9): [True: 26, False: 817]
  ------------------
  129|     26|      throw MOADNSException("NSEC record with invalid bitmap length");
  130|     26|    }
  131|       |
  132|    817|    if (position + blen > bitmap.size()) {
  ------------------
  |  Branch (132:9): [True: 15, False: 802]
  ------------------
  133|     15|      throw MOADNSException("NSEC record with bitmap length > packet length");
  134|     15|    }
  135|       |
  136|    802|    lastWindowSeen = window;
  137|       |
  138|  8.39k|    for (unsigned int k = 0; k < blen; k++) {
  ------------------
  |  Branch (138:30): [True: 7.58k, False: 802]
  ------------------
  139|  7.58k|      uint8_t val = bitmap.at(position++);
  140|  68.2k|      for (int bit = 0; bit < 8 ; ++bit , val >>= 1U) {
  ------------------
  |  Branch (140:25): [True: 60.7k, False: 7.58k]
  ------------------
  141|  60.7k|        if ((val & 1U) != 0) {
  ------------------
  |  Branch (141:13): [True: 39.0k, False: 21.6k]
  ------------------
  142|  39.0k|          set((7 - bit) + (8 * k) + (256 * window));
  143|  39.0k|        }
  144|  60.7k|      }
  145|  7.58k|    }
  146|    802|  }
  147|       |
  148|    398|  if (position != bitmap.size()) {
  ------------------
  |  Branch (148:7): [True: 27, False: 371]
  ------------------
  149|     27|    throw MOADNSException("NSEC record does not use all the record bytes");
  150|     27|  }
  151|       |
  152|    398|}
_ZN17NSECRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  182|      1|{
  183|      1|  regist(1, 47, &make, &make, "NSEC");
  184|      1|}
_ZN17NSECRecordContent4makeERK9DNSRecordR12PacketReader:
  210|    589|{
  211|    589|  auto ret=std::make_shared<NSECRecordContent>();
  212|    589|  pr.xfrName(ret->d_next);
  213|       |
  214|    589|  ret->d_bitmap.fromPacket(pr);
  215|    589|  if (!pr.eof()) {
  ------------------
  |  Branch (215:7): [True: 0, False: 589]
  ------------------
  216|      0|    throw MOADNSException("When parsing NSEC trailing data was not parsed: '" + pr.getRemaining() + "'");
  217|      0|  }
  218|       |
  219|    589|  return ret;
  220|    589|}
_ZN18NSEC3RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  234|      1|{
  235|      1|  regist(1, 50, &make, &make, "NSEC3");
  236|      1|}
_ZN18NSEC3RecordContent4makeERK9DNSRecordR12PacketReader:
  275|    187|{
  276|    187|  auto ret=std::make_shared<NSEC3RecordContent>();
  277|    187|  pr.xfr8BitInt(ret->d_algorithm);
  278|    187|  pr.xfr8BitInt(ret->d_flags);
  279|    187|  pr.xfr16BitInt(ret->d_iterations);
  280|    187|  uint8_t len;
  281|    187|  pr.xfr8BitInt(len);
  282|    187|  pr.xfrBlob(ret->d_salt, len);
  283|       |
  284|    187|  pr.xfr8BitInt(len);
  285|    187|  pr.xfrBlob(ret->d_nexthash, len);
  286|       |
  287|    187|  ret->d_bitmap.fromPacket(pr);
  288|    187|  if (!pr.eof()) {
  ------------------
  |  Branch (288:7): [True: 0, False: 187]
  ------------------
  289|      0|    throw MOADNSException("When parsing NSEC3 trailing data was not parsed: '" + pr.getRemaining() + "'");
  290|      0|  }
  291|    187|  return ret;
  292|    187|}
_ZN23NSEC3PARAMRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  310|      1|{
  311|      1|  regist(1, 51, &make, &make, "NSEC3PARAM");
  312|      1|  regist(254, 51, &make, &make, "NSEC3PARAM");
  313|      1|}
_ZN23NSEC3PARAMRecordContent4makeERK9DNSRecordR12PacketReader:
  340|     69|{
  341|     69|  auto ret=std::make_shared<NSEC3PARAMRecordContent>();
  342|     69|  pr.xfr8BitInt(ret->d_algorithm);
  343|     69|        pr.xfr8BitInt(ret->d_flags);
  344|     69|        pr.xfr16BitInt(ret->d_iterations);
  345|     69|  uint8_t len;
  346|     69|  pr.xfr8BitInt(len);
  347|     69|  pr.xfrHexBlob(ret->d_salt, len);
  348|     69|  return ret;
  349|     69|}
_ZN18CSYNCRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  367|      1|{
  368|      1|  regist(1, 62, &make, &make, "CSYNC");
  369|      1|}
_ZN18CSYNCRecordContent4makeERK9DNSRecordR12PacketReader:
  398|    125|{
  399|    125|  auto ret=std::make_shared<CSYNCRecordContent>();
  400|    125|  pr.xfr32BitInt(ret->d_serial);
  401|    125|  pr.xfr16BitInt(ret->d_flags);
  402|       |
  403|    125|  ret->d_bitmap.fromPacket(pr);
  404|    125|  if (!pr.eof()) {
  ------------------
  |  Branch (404:7): [True: 0, False: 125]
  ------------------
  405|      0|    throw MOADNSException("When parsing CSYNC trailing data was not parsed: '" + pr.getRemaining() + "'");
  406|      0|  }
  407|    125|  return ret;
  408|    125|}

qtype.cc:_ZL12swapElementsRKNSt3__13mapIKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEtNS_4lessIS7_EENS4_INS_4pairIS7_tEEEEEE:
  103|      2|{
  104|      2|  std::map<uint16_t, const std::string> ret;
  105|       |
  106|    138|  for (const auto& name : names) {
  ------------------
  |  Branch (106:25): [True: 138, False: 2]
  ------------------
  107|    138|    ret.emplace(name.second, name.first);
  108|    138|  }
  109|      2|  return ret;
  110|      2|}

_ZNK6QClasscvtEv:
  201|  23.4k|  {
  202|  23.4k|    return qclass;
  203|  23.4k|  }

_ZN16LOCRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes:
  202|      1|{
  203|      1|  regist(1, QType::LOC, &make, &make, "LOC");
  204|      1|  regist(254, QType::LOC, &make, &make, "LOC");
  205|      1|}
_ZN16LOCRecordContent4makeERK9DNSRecordR12PacketReader:
  226|    106|{
  227|    106|  auto ret=std::make_shared<LOCRecordContent>();
  228|    106|  pr.xfr8BitInt(ret->d_version);
  229|    106|  pr.xfr8BitInt(ret->d_size);
  230|    106|  pr.xfr8BitInt(ret->d_horizpre);
  231|    106|  pr.xfr8BitInt(ret->d_vertpre);
  232|       |
  233|    106|  pr.xfr32BitInt(ret->d_latitude);
  234|    106|  pr.xfr32BitInt(ret->d_longitude);
  235|    106|  pr.xfr32BitInt(ret->d_altitude);
  236|    106|  if (!pr.eof()) {
  ------------------
  |  Branch (236:7): [True: 4, False: 102]
  ------------------
  237|      4|    throw MOADNSException("When parsing LOC trailing data was not parsed: '" + pr.getRemaining() + "'");
  238|      4|  }
  239|       |
  240|    102|  return ret;
  241|    106|}

_ZN7StatBagC2Ev:
   40|      2|{
   41|      2|  d_doRings=false;
   42|      2|  d_allowRedeclare=false;
   43|      2|}

_ZN8SvcParam11keyToStringERKNS_11SvcParamKeyE:
   66|     18|{
   67|     18|  auto ret = std::find_if(SvcParams.begin(), SvcParams.end(), [&](const std::pair<std::string, SvcParam::SvcParamKey>& e) { return e.second == k; });
   68|     18|  if (ret != SvcParams.end()) {
  ------------------
  |  Branch (68:7): [True: 18, False: 0]
  ------------------
   69|     18|    return ret->first;
   70|     18|  }
   71|      0|  return "key" + std::to_string(k);
   72|     18|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyE:
   75|     58|{
   76|     58|  d_key = key;
   77|     58|  if (d_key != SvcParamKey::no_default_alpn && d_key != SvcParamKey::ohttp && d_key != SvcParamKey::pvd) {
  ------------------
  |  Branch (77:7): [True: 38, False: 20]
  |  Branch (77:48): [True: 20, False: 18]
  |  Branch (77:79): [True: 0, False: 20]
  ------------------
   78|      0|    throw std::invalid_argument("can not create non-empty SvcParam for key '" + keyToString(key) + "'");
   79|      0|  }
   80|     58|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   83|    443|{
   84|    443|  d_key = key;
   85|    443|  if (d_key != SvcParamKey::ech && d_key != SvcParamKey::dohpath && d_key < 11) {
  ------------------
  |  Branch (85:7): [True: 410, False: 33]
  |  Branch (85:36): [True: 397, False: 13]
  |  Branch (85:69): [True: 0, False: 397]
  ------------------
   86|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string value");
   87|      0|  }
   88|    443|  if (d_key == SvcParamKey::ech) {
  ------------------
  |  Branch (88:7): [True: 33, False: 410]
  ------------------
   89|     33|    std::string d;
   90|       |    // TODO check Base64 decode
   91|     33|    d_ech = value;
   92|     33|    return;
   93|     33|  }
   94|    410|  d_value = value;
   95|    410|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
   98|    105|{
   99|    105|  d_key = key;
  100|    105|  if (d_key != SvcParamKey::alpn && d_key != SvcParamKey::docpath) {
  ------------------
  |  Branch (100:7): [True: 26, False: 79]
  |  Branch (100:37): [True: 0, False: 26]
  ------------------
  101|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value");
  102|      0|  }
  103|    105|  d_alpn = std::move(value);
  104|    105|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__13setIS0_NS3_4lessIS0_EENS3_9allocatorIS0_EEEE:
  120|    181|{
  121|    181|  d_key = key;
  122|    181|  if (d_key != SvcParamKey::mandatory) {
  ------------------
  |  Branch (122:7): [True: 0, False: 181]
  ------------------
  123|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a SvcParamKey-set value");
  124|      0|  }
  125|    181|  d_mandatory = std::move(value);
  126|    181|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorI12ComboAddressNS3_9allocatorIS5_EEEE:
  129|    144|{
  130|    144|  d_key = key;
  131|    144|  if (d_key != SvcParamKey::ipv6hint && d_key != SvcParamKey::ipv4hint) {
  ------------------
  |  Branch (131:7): [True: 106, False: 38]
  |  Branch (131:41): [True: 0, False: 106]
  ------------------
  132|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with an IP address value");
  133|      0|  }
  134|  31.7k|  for (auto const& addr : value) {
  ------------------
  |  Branch (134:25): [True: 31.7k, False: 144]
  ------------------
  135|  31.7k|    if (d_key == SvcParam::ipv6hint && !addr.isIPv6()) {
  ------------------
  |  Branch (135:9): [True: 361, False: 31.3k]
  |  Branch (135:40): [True: 0, False: 361]
  ------------------
  136|      0|      throw std::invalid_argument("non-IPv6 address ('" + addr.toString() + "') passed for " + keyToString(key));
  137|      0|    }
  138|  31.7k|    if (d_key == SvcParam::ipv4hint && !addr.isIPv4()) {
  ------------------
  |  Branch (138:9): [True: 31.3k, False: 361]
  |  Branch (138:40): [True: 0, False: 31.3k]
  ------------------
  139|      0|      throw std::invalid_argument("non-IPv4 address ('" + addr.toString() + "') passed for " + keyToString(key));
  140|      0|    }
  141|  31.7k|  }
  142|    144|  d_ipHints = std::move(value);
  143|    144|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorItNS3_9allocatorItEEEE:
  146|     84|  d_key(key)
  147|     84|{
  148|     84|  if (d_key != SvcParamKey::tls_supported_groups) {
  ------------------
  |  Branch (148:7): [True: 0, False: 84]
  ------------------
  149|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a uint16 value-vector");
  150|      0|  }
  151|     84|  d_tls_supported_groups = std::move(value);
  152|     84|}
_ZN8SvcParamC2ERKNS_11SvcParamKeyEt:
  155|     12|{
  156|     12|  d_key = key;
  157|     12|  if (d_key != SvcParamKey::port) {
  ------------------
  |  Branch (157:7): [True: 0, False: 12]
  ------------------
  158|      0|    throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a port value");
  159|      0|  }
  160|     12|  d_port = value;
  161|     12|}
_ZNK8SvcParamltERKS_:
  165|  1.70k|{
  166|  1.70k|  return this->d_key < other.getKey();
  167|  1.70k|}
svc-records.cc:_ZZN8SvcParam11keyToStringERKNS_11SvcParamKeyEENK3$_0clERKNSt3__14pairINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEES0_EE:
   67|    167|  auto ret = std::find_if(SvcParams.begin(), SvcParams.end(), [&](const std::pair<std::string, SvcParam::SvcParamKey>& e) { return e.second == k; });

_ZNK8SvcParam6getKeyEv:
   99|  1.70k|  {
  100|  1.70k|    return d_key;
  101|  1.70k|  }
_ZN8SvcParam11setAutoHintEb:
  112|    144|  void setAutoHint(const bool value) { d_autohint = value; };

_ZN4pdns5views16UnsignedCharViewC2EPKcm:
   33|  21.6k|    view(data_, size_)
   34|  21.6k|  {
   35|  21.6k|  }
_ZNK4pdns5views16UnsignedCharView2atEm:
   44|  75.9k|  {
   45|  75.9k|    return reinterpret_cast<const unsigned char&>(view.at(pos));
   46|  75.9k|  }
_ZNK4pdns5views16UnsignedCharView4sizeEv:
   60|  41.5k|  {
   61|  41.5k|    return view.size();
   62|  41.5k|  }

